Zu beschreiben was Mathematica war und ist ist gar nicht ganz einfach. Es wurde ursprünglich von einem Physiker als Computeralgebrasystem zur symbolischen Verarbeitung von Gleichungen und Differentialgleichungen entwickelt. Die Programmiersprache von Mathematica (Wolfram Language)ist stark an die funktionale Programmiersprache Lisp angelehnt. Zusätzlich basiert Mathematica wesentlich auf Pattern Matching. Dies sorgt besonders bei Einsteigern für Verwirrung, weil Patterns, also Muster-Platzhalter, vorkommen, sobald man mit Funktionen arbeitet. Zusammen mit den fast ständig genutzten eckigen Klammern entsteht so ein Code-Aussehen, das sich stark von den verbreiteten Programmiersprachen unterscheidet. Daher bedarf es einiger Mühe sich mit diesem neuartigen Programmier-Paradigma anzufreunden.
Ist diese Hürde aber einmal genommen, tut sich eine neuartige Welt der Berechenbarkeit auf. Stephen Wolfram, erkannte sehr schnell, dass die zugrundeliegenden Konzepte nicht nur für die Mathematik zu gebrauchen sind, sondern sich damit die gesamte Breite der technisch-wissenschaftlichen Berechnungen erschliessen lässt.
Im folgenden sollen in kompakter Form die wesentlichen Konzepte vorgestellt werden, die einen Einstieg ermöglichen. Das gesamte System vorzustellen, würde diesen Rahmen sprengen. In der aktuellen Version 14 sind mehr als 6600 Funktionen enthalten, deren Dokumentation zigtausend Seiten beinhaltet und über 75GB umfasst. Von daher sollen hier die essentiellen Konzepte vorgestellt werde, mit deren Hilfe man sich Schritt für Schritt weiter einarbeiten kann.
Üblicherweise beginnt eine Mathematica Session damit, dass man ein Notebook erstellt oder ein vorhandenes öffnet. Ein Notebook ist das universelle Ein- und Ausgabemedium von Mathematica und ermöglicht so den Zugriff auf die Funktionen und Programmierkonzepte der Wolfram Language. Ein Notebook kann man sich als elektronisches Aquivalent eiens Notizblocks vorstellen: Man kann Text eingeben, gibt Ausdrücke, Zahlen oder Zeichenketten ein, die der eingebaute Interpreter dann auswertet und das berechnete Ergebnis wieder im Notebook ausgibt. Als erstes Beispiel kann man folgenden Ausdruck eingeben und mit Shift+Enter Mathematica anweisen, den Ausdruck auszuwerten:
Scheinbar mühelos multipliziert Mathematica durch die Funktion Expand [...] die Ausdrücke aus und stellt sie zusammengefasst dar. Hier erkennt man auch die Verwendung eines der zentralen Konzepte von Mathematica die Klammern. welche Bedeutung Klammern haben. Mathematica kennt drei Arten von Klammern:
Diese verschiedenen Klammer-Arten wirken Anfangs etwas verwirrend, sind aber sehr wichtig. Daher sollte man als Beginner, sehr genau darauf achten, wenn man die unterschiedlichen Bedeutungen aber erst einmal verinnerlicht hat, gelingt es mehr und mehr sicher damit umzugehen.
Mathematica unterscheidet drei Arten von Funktionen. Einerseits die (fast schon als traditionell zu bezeichnenden) mathematische Funktionen wie $Sin[x], Cos[x], \dots $ Dann gibt es die Möglichkeit, eigene Funktionen zu definieren. Und schliesslich bietet Mathematica eingebaute Funktionen zur Berechnung von unterschiedlichen Problemen. Wobei letztere keine Funktionen im strengen Sinne der Mathematik darstellen, sondern Funktionen wie sie in den Computer Wissenschaften verwendet werden.
Ein Beispiel als eine von vielen eingebauten Funktionen wäre die Funktion Solve [...] zu nennen. Die Funktion Solve dient dazu, symbolisch Gleichungen oder Gleichungssysteme zu lösen. Sie liefert exakte Lösungen in Form von Ersetzungsregeln.
Solve[x^2 == 4]
{{x -> -2}, {x -> 2}}
Die Funktion Solve dient dazu, symbolisch Gleichungen oder Gleichungssysteme zu lösen. Sie liefert exakte Lösungen in Form von Ersetzungsregeln. Man erkennt, dass Mathematica das berechnete Ergebnis in Form einer Liste zurück gibt. Also nicht in der Form $x1=-2, \; x2=2$, sondern als Liste.
Eine Regelliste (engl. list of rules) ist eine Sammlung von Ersetzungsregeln, die in der Wolfram Language verwendet wird, um Ausdrücke zu transformieren oder zu vereinfachen. Sie ist das typische Ergebnis von Funktionen wie Solve, DSolve, FindRoot etc. Eine Regel hat folgende Form:
variable -> wert
{{x -> -2}, {x -> 2}}
Man kann nun mit diesen Regellisten weiter arbeiten und sie beispielsweise auf einen Ausdruck anwenden. Dazu gibt es spezielle Operatoren hier nutzen wir den ReplaceAllOperator abgekürzt "/.":
x^2 /. {x->3}
ergiebt 9
Um einen ersten Eindruck zu vermitteln, wie diese verschiedenen Funktionen verwendet werden, hier ein konkretes Beispiel. Die Aufgabe sei: Finde alle Palindromzahlen kleiner als Tausend.
Eine Zahl ist ein Palindrom, wenn sie der Zahl entspricht, die durch Umkehrung ihrer Ziffern gebildet wird. Zum Beispiel ist 1552551 ein Palindrom.
Zur Lösung verwenden wir zwei der eingebauten Funktionen: IntegerDigits[n] und Reverse[]. Erstere gibt eine Liste der Dezimalstellen der Zahl n aus. Reverse[]dreht die Reihenfolge des Ausdrucks um.
IntegerDigits[1552551]
ergibt die Liste: {1, 5, 5, 2, 5, 5, 1}
Reverse[IntegerDigits[1552551]]
{1, 5, 5, 2, 5, 5, 1}
Möchte man nun wissen, ob beide Ausdrücke gleich sind schreibt man:
IntegerDigits[1552551] == Reverse[IntegerDigits[1552551]]
True
Nun erstellt man eine eigene Funktion, die prüft ob beide Listen identisch sind. Diese benutzerdefinierte Funktion lässt sich im Rahmen des aktuellen Notebooks, so verwenden, als handelte es sich um eine eingebaute Funktion.
PalinQ[n_] := IntegerDigits[n] == Reverse[IntegerDigits[n]]
Test: PalinQ[1235431]
False
PalinQ[8771778]
True
Um eine Liste der ersten tausend Zahlen zu erhalten, verwendet man die Funktion Range[]. Zusammen mit der Funktion Select[], die alle Zahlen aus der Liste herausfiltert, die das Kriterium erfüllen. In unserem Fall ein Palindrom bilden:
PalinQ[n_] := IntegerDigits[n] == Reverse[IntegerDigits[n]]
Select[Range[10^3], PalinQ]
{1, 2, 3, 4, 5, 6, 7, 8, 9, 11, 22, 33, 44, 55, 66, 77, 88, 99, 101, \
111, 121, 131, 141, 151, 161, 171, 181, 191, 202, 212, 222, 232, 242, \
252, 262, 272, 282, 292, 303, 313, 323, 333, 343, 353, 363, 373, 383, \
393, 404, 414, 424, 434, 444, 454, 464, 474, 484, 494, 505, 515, 525, \
535, 545, 555, 565, 575, 585, 595, 606, 616, 626, 636, 646, 656, 666, \
676, 686, 696, 707, 717, 727, 737, 747, 757, 767, 777, 787, 797, 808, \
818, 828, 838, 848, 858, 868, 878, 888, 898, 909, 919, 929, 939, 949, \
959, 969, 979, 989, 999}
Die Definition eigener Funktionen ist in Mathematica sehr elegant und flexibel. Hier sind die wichtigsten Methode: Die Definition beginnt mit einem Funktions-Namen. Dieser sollte so gewählt werden, dass er sich von den eingebauten Funktionen unterscheidet und keine Namenskollision entsteht. Dann folgt einer oderer mehrere Platzhalter (Patterns) die mit einem Unterstrich gekennzeichnet werden.
(*Beispiele von Funktions-Definitionen*)
f[x_] := x^2 + 3
f[2] (* ergibt 7 *)
(* mit mehreren Variablen *)
g[x_, y_] := x^2 + y^2
g[3, 4] (* ergibt 25 *)
(* mit Bedingungen nur wenn x>0 gibt wird ein Wert ausgegeben*)
h[x_] := x^2 /; x > 0
(* Rekursive Funktionen *)
fak[0] := 1
fak[n_] := n * fak[n - 1]
(* anonyme (pure) Funktionen *)
square = Function[x, x^2]
square[5] (* ergibt 25 *)
(* Kürzer *)
square2 = #^2 &;
square2[6] (* ergibt 36 *)
Die Ableitung einer Funktion gehört zu den wichtigsten Konzepten in der Wisenschaft. Die Ableitung führt zur sogenannten Ableitungsfunktion, die angibt, wie steil oder flach die ursprüngliche Funktion an jedem Punkt ist. Viele Schüler und Studenten tun sich etwas schwer, wenn es darum geht sich die Ableitung einer Funktion vorzustellen. Sie können zwar häufig durch die Anwendung der Ableitungsregeln, die Funktion ableiten, oft ist es aber mehr als nur hilfreich, wenn man auch versteht, was sich hinter dieser elementaren Operation verbirgt. Im folgenden soll mit Hilfe von Mathematica vorgestellt werden, wie die Ableitungs-Operation visualisiert werden kann.
Ableiten heisst nichts anderes, als die Steigung eines Punktes P auf einem Graphen G zu bestimmen. Was dem Anlegen einer Tangente an diesen Punkt entspricht. Eine positive Ableitung heißt: die Funktion steigt am Punkt P an. Entsprechend bedeutet ein negativer Wert, dass die Funktion abfällt. Sollte sie gleich Null sein, handelt es sich um ein Extremwert also einen Hoch- oder Tiefpunkt.
Softwaresysteme wie Mathematica stellt Mechanismen bereit, die es ermöglichen, nicht symbolisch abzuleiten (was natürlich eine enorme Versuchung darstellt, sich nicht mehr mit den Regeln zu befassen), sondern auch zu visualisieren was da passiert. Schauen wir uns das am Beispiel einer Funktion und ihrer zugehörigen Ableitung-Funktion an:
An diesem Beispiel erkennt man wie die drei Funktionen zusammen hängen. Schauen wir uns den Punkt P(1,0) an. Hier scheinen alle drei Funktionen eine Nullstelle zu besitzen. Dies läßt sich nun sehr leicht überprüfen in dem man folgendes eingibt:
f[1] == f'[1] == f''[1]
Damit schliesst sich unmittelbar die Frage an, was das bedeutet. Diese Frage wird ausführlich in einer Kurven-Diskussion beantwortet. Hier soll es vorläufig "nur" um die Veranschaulichung der Ableitung gehen.
Als ersten Schritt kann man sich den Graph erstmals als Menge von Punkten vorstellen. Die man sich anschliessend auf den Graphen projeziert:
(* Erstelle Punkte-Liste basierend auf f[x] *)
Punktliste = Table[{x, f[x]}, {x, -4, 4, 0.25}]
{{-2., 0.}, {-1.75, -5.19922}, {-1.5, -7.8125}, {-1.25, -8.54297}, \
{-1., -8.}, {-0.75, -6.69922}, {-0.5, -5.0625}, {-0.25, -3.41797}, \
{0., -2.}, {0.25, -0.949219}, {0.5, -0.3125}, {0.75, -0.0429688}, {1.,
0.}, {1.25, 0.0507813}, {1.5, 0.4375}, {1.75, 1.58203}, {2., 4.}}
Plot[f[x], {x, -2, 2},
Epilog -> {PointSize[0.015], Hue[1], Map[Point, Punktliste]}]
Nun stellt sich die Frage, wie man für alle diese Punkte eine Tangentengleichung bestimmt werden kann. Ausgangspunkt ist die bekannte Geradengleichung: y= mx+b , Wobei m die Steigung beschreibt und b den y-Achsenabschnitt also den Abstand zur x-Achse bezeichnet.
Mit Mathematica lässt sich das Problem relativ einfach lösen. Man definiert die Ausgangsfunktion f(x) und die allgemeine Tangentengleichung t(x) und den Punkt a und lässt sich das Ganze dann über die Plot-Funktion anzeigen.
Tangentenliste =
Table[{{x, f[x]}, {(x + 0.25), f[x] + f'[x]*0.9}}, {x, -2, 2, 0.25}]
(*Mit Ableitungsfunktion*)
Show[{Plot[f[x], {x, -2, 2}, PlotStyle -> {Blue},
PlotLegends -> Placed[{"f(x)"}, Above], AxesLabel -> {"x", "y"},
GridLines -> Automatic,
Epilog -> {PointSize[0.02], Red, Map[Point, Punktliste]}],
Graphics[{Orange, Thick, Map[Arrow, Tangentenliste]}],
Plot[f'[x], {x, -2, 2}, PlotStyle -> {Gray},
PlotLegends -> Placed[{"f'(x)"}, Above]]}]
(*Ohne Ableitungsfunktion*)
Show[{ Plot[
f[x],
{x, -2, 2},
PlotStyle -> {Darker[Blue, 0.3]},
PlotLegends -> Placed[{"f(x)"}, Above],
AxesLabel -> {"x", "y"},
GridLines -> Automatic,
Epilog -> {
PointSize[0.02],Red, Map[Point, Punktliste] } ],
Graphics[ { Orange, Thick, Map[Arrow, Tangentenliste]
} ] }
]
Bei der Kurvendiskussion geht es darum, eine mathematische Funktion zu untersuchen, d.h. das Verhalten zu beschreiben und interpretieren zu können. Dazu gibt es eine Menge von Eigenschaften, die von besonderem Interesse sind. Beispielsweise die Nullstellen oder die Extremwerte. Nachfolgend aufgeführte Eigenschaften verschaffen einen guten Überblick über eine Funktion:
Mit den Methoden der Analysis lassen sich diese Eigenschaften bestimmen. Beispielsweise durch die Bestimmung der Ableitung, die Integration, Grenzwertbetrachtungen etc. Im folgenden Beitrag wird an einem Beispiel eine vollständige Kurvendiskussion durchgeführt und beispielhaft die Methodik erklärt, die sich dann auf beliebte andere Funktionen übertragen lässt. Das Beispiel soll folgende Funktion sein:
\begin{eqnarray} f(x) = x^4-x^3-3x^2+5x+2 \end{eqnarray}Das bedeutet, die Funktion ist für alle reellen Zahlen definiert !
Die Nullstellen einer Funktion f(x) sind die Stellen an denen f(x)=0 gilt. Oder geometrisch gesehen die Schnittpunkte des Graphen der Funktion f(x) mit der x-Achse. D.h. man bestimmt die Nullstellen einer Funktion dadurch das man sie gleich Null setzt und durch verschiedenste Verfahren, dann die x-Werte bestimmt, an denen die Bedingung erfüllt ist. Mögliche Verfahren sind hier die Mitternachtsformel, das Horner-Schema oder auch die Linearfaktor-Zerlegung. Manchmal muss man einfach auch mal durch systematisches Probieren eine erste Nullstelle ermitteln, um dann weiter zu rechnen. In unserem Beispiel kann man wie folgt vorgehen:
(* Definition von f[x] *)
f[x_] := x^4 - x^3 - 3 x^2 + 5 x - 2
(* Bestimmung der Nullstellen f[x] *)
Solve[f[x] == 0]
{{x -> -2}, {x -> 1}, {x -> 1}, {x -> 1}}
(* Schnittpunkt y-Achse *)
f[0]
-2
Die Schnittstelle mit der y–Achse ist der Punkt wo der Graph die y–Achse schneidet. Der x-Wert, an dem die Funktion die y–Achse schneidet, ist immer null. Daher lässt sich der y-Wert genau dadurch bestimmen, in dem der Wert x=0 in die Funktionsgleichung eingesetzt wird. Bitte nicht mit der Bestimmung der Nullstelle verwechseln, wo der Wert y=0 gesetzt wird. In unserem Beispiel setzten wir also x=0 in f ein und bestimmen somit f(0):
Man unterscheidet zwei Arten von Symmetrie: Punktsymmetrie und Achsensymmetrie. Eine Funktion ist punktsymmetrisch, wenn es irgendeinen Punkt gibt, an dem man die Funktion derart spiegeln kann, dass als Spiegelbild wieder die gleiche Funktion rauskommt.
Eine Funktion ist dagegen achsensymmetrisch, wenn es eine Gerade [also eine Achse] gibt, an der man die Funktion derart spiegeln kann, dass als Spiegelbild wieder die gleiche Funktion rauskommt. Um herauszufinden ob eine Funktion symmetrisch ist gibt es zwei Formeln:
Es gibt allerdings auch bei der Symmetrie-Untersuchung ganzrationalen Funktionen einen Trick. Bei dieser Art von Funktionen schaut man sich nur die Hochzahlen der Variablen an. Gibt es nur gerade Hochzahlen, ist f(x) symmetrisch zur y-Achse. Ein Beispiel für so eine Funktion wäre: $f(x) = 2x^6–3x^4–5$
Gibt es nur ungerade Hochzahlen, ist f(x) symmetrisch zum Ursprung. Beispiel: $f(x) = 2x^5+12x^3–2x$
Gibt es gemischte Hochzahlen, ist f(x) nicht symmetrisch. Beispiele: $f(x) = x^3+2x^2–3x+4$
In unserem Beispiel handelt es sich um Polynom mit gemischten Hochzahlen, woraus wir ableiten können, dass keine Symmetrie vorliegt.
Bei dieser Untersuchung prüft man wie sich die Funktion verhält, wenn die X-Werte gegen plus oder minus Unendlich gehen. Dabei kommt es immer auf den Faktor mit der größten Hochzahl an, da dieser das Verhalten am stärksten beeinflusst. In unserem Beispiel wäre das der Faktor $x^4$. Möchte man nun wissen, wie das Verhalten im Unendlichen aussieht, setzt man gedanklich eine ganz große negative und eine positive Zahl ein und erkennt, dass durch die geradzahlige Hochzahl in beiden Fällen $f(x) \to +\infty$ strebt.
(* Verhalten im Unendlichen von f[x] *)
f[x_] := x^4 - x^3 - 3 x^2 + 5 x - 2
f[10^9] -> 999999998999999997000000004999999998
(* Bestimmung mit Mathematica *)
Limit[f[x], x -> \[Infinity]]
Die Bestimmung der Extremwerte gehört zu den wichtigsten Untersuchungen. Als Extremwerte werden die Hochpunkte, Tiefpunkte und Sattelpunkte einer Funktion bezeichnet. Die Berechnung erfolgt immer nach dem geglichen Schema:
Um also die Extremwerte und Wendepunkte zu bestimmen, müssen die drei Ableitungen berechnet werden, dann die Nullstellen der 2ten Ableitungen gebildet werden und schliesslich noch die 3te ABleitung gebildet werden, um herauszufinden, ob ein Wendepunkt vorliegt:
f[x_] := x^4 - x^3 - 3 x^2 + 5 x - 2
f'[x] -> 5 - 6 x - 3 x^2 + 4 x^3
f''[x] -> -6 - 6 x + 12 x^2
f'''[x] -> -6 + 24 x
Solve[f''[x] == 0] --> {{x -> -(1/2)}, {x -> 1}}
(*Einsetzen der Werte in die 3te Ableitung*)
f'''[x] /. % --> {-18, 18}
(*Alternativ händisch*)
f'''[-1/2] und f'''[1]
Somit erhalten wir durch Einsetzen der gefundenen Nullstellen der zweiten Ableitung für f'''(1) = 18 und f'''(-0,5) = -18 woraus wir erkennen, dass an beiden Punkten ein Wendepunkt vorliegt, da das oben genannte Kriterium f’’(x) = 0 und f’’’(x) ≠ 0 erfüllt ist. Wir halten somit fest, es gibt 2 Wendepunkte: $$ WP_1 = [f(-0.5),-0.5)] = (-5.06 \;| -0.5) \qquad WP_2 =[f(1);1)] = (0 | 1) $$
Hierzu bietet Mathematica vielfältige Möglichkeiten. Um sich nicht völlig auf das Computersystem zu verlassen starte ich immer mit einer Wertetabelle. Damit erkennt man schon einmal den groben Verlauf um den Graph darzustellen. Die lässt sich sehr einfach mit Mathematica erzeugen:
f[x_] := x^4 - x^3 - 3 x^2 + 5 x - 2
f'[x] -> 5 - 6 x - 3 x^2 + 4 x^3
f''[x] -> -6 - 6 x + 12 x^2
f'''[x] -> -6 + 24 x
Table[{x, f[x]}, {x, -4, 4}]
{{-4, 250}, {-3, 64}, {-2, 0}, {-1, -8}, {0, -2}, {1, 0}, {2, 4}, {3,
40}, {4, 162}}
Die Plot-Funktion von Mathematica bietet verschiedene Möglichkeiten den Graph darzustellen. Hier noch einmal die Bestimmung sämtlicher Werte, die sich auch im Funktionsgraph visualisieren lassen:
(*Nullstellen*)nullstellen = x /. NSolve[f[x] == 0, x];
(*Extremstellen:f'(x)=0*)
extrema = x /. NSolve[D[f[x], x] == 0, x];
(*Wendepunkte:f''(x)=0*)
wendepunkte = x /. NSolve[D[f[x], {x, 2}] == 0, x];
Plot[f[x], {x, -3.5, 3.5}, PlotStyle -> {Thick, Blue},
AxesLabel -> {"x", "f(x)"}, PlotRange -> All, GridLines -> Automatic,
Frame -> True,
Epilog -> {Red, PointSize[0.03],
Point[Table[{x, f[x]}, {x, nullstellen}]], Green, PointSize[0.03],
Point[Table[{x, f[x]}, {x, extrema}]], Orange, PointSize[0.03],
Point[Table[{x, f[x]}, {x, wendepunkte}]]},
PlotLegends -> Placed[{"f(x)"}, Above]]
Mit etwas mehr Mathematica Code, lässt sich noch mehr darstellen. Insbesondere wenn es um die Umgebung der berechneten Punkte gehen soll. Hier ein Beispiel:
(*Beispiel-Funktion*)f[x_] := x^4 - x^3 - 3 x^2 + 5 x - 2;
(*Nullstellen*)
nullstellen = x /. NSolve[f[x] == 0, x];
(*Extremstellen*)
extrema = x /. NSolve[D[f[x], x] == 0, x];
(*Wendepunkte*)
wendepunkte = x /. NSolve[D[f[x], {x, 2}] == 0, x];
(*Hilfsfunktion zum Markieren von Punkten*)
punkteGrafik[stellen_, farbe_] :=
Graphics[{farbe, PointSize[0.02], Point[{#, f[#]}] & /@ stellen}];
(*Legendenfunktion*)
legende =
SwatchLegend[{Blue, Red, Green, Orange}, {"f(x)", "Nullstelle",
"Extrem", "Wendepunkt"}];
(*Plot 1:Gesamtübersicht*)
plotGesamt =
Legended[
Show[Plot[f[x], {x, -3.5, 3.5}, PlotStyle -> {Thick, Blue},
AxesLabel -> {"x", "f(x)"}, GridLines -> Automatic,
Frame -> True], punkteGrafik[nullstellen, Red],
punkteGrafik[extrema, Green], punkteGrafik[wendepunkte, Orange]],
legende];
(*Plot 2:Zoom auf Extremstellen*)
xExtremaMin = Min[extrema] - 0.5;
xExtremaMax = Max[extrema] + 0.5;
plotExtrema =
Show[Plot[f[x], {x, xExtremaMin, xExtremaMax},
PlotStyle -> {Thick, Blue}, AxesLabel -> {"x", "f(x)"},
Frame -> True], punkteGrafik[extrema, Green]];
(*Plot 3:Zoom auf Wendepunkte*)
xWendeMin = Min[wendepunkte] - 0.5;
xWendeMax = Max[wendepunkte] + 0.5;
plotWendepunkte =
Show[Plot[f[x], {x, xWendeMin, xWendeMax},
PlotStyle -> {Thick, Blue}, AxesLabel -> {"x", "f(x)"},
Frame -> True], punkteGrafik[wendepunkte, Orange]];
(*Alle untereinander anzeigen*)
GraphicsGrid[{{plotGesamt}, \
{plotExtrema}, {plotWendepunkte}}, Spacings -> 2]
Das Monotonieverhalten einer Funktion gibt an, in welchem Bereich der Graph der Funktion steigt oder fällt. Daher ist das Monotonieverhalten wie folgt definiert: Die Funktion f ist streng monoton steigend, wenn $f'(x) > 0$ gilt. Die Funktion $f$ ist streng monoton fallend, wenn $f'(x) < 0$ gilt.
Wichtig ist hierbei, dass Monotonie nur für die Teile des Definitionsbereiches betrachtet wird, in dem die Funktion stetig ist. Wenn bei einer Funktion Unterbrechungen existieren gibt es an diesen Stellen keine Monotonie. Daher ist es wichtig den Definitionsbereich der Funktion zu kennen. In unserem Beispiel ist $f'(x) = 4x^3-3x^2-6x+5$ die in orange eingezeichnete Kurve. Um das Monotonie Verhalten von f(x) (der rot eingezeichneten Kurve) zu bestimmen, erstellt man am einfachsten eine Wertetabelle und zeichnet beide Funktionen in ein Diagramm.
Man erkennt am Verlauf sehr gut, in welchen Bereichen der Wert von f'(x) kleiner Null ist und somit deutlich wird, dass f(x) monoton fallend ist. Im obigen Beispiel ist f´(x) im Intervall $ [- \infty \to -5/4]$ kleiner Null, somit hat die Ausgangsfunktion f(x) hier ein monoton fallendes Verhalten. Was man am Verlauf des Graphen (in rot dargestellt) sehr gut erkennen kann. Ebenso erkennt man, wo der Wert von f'(x) (grüne gestrichelte Darstellung) größer Null ist, was gleichbedeutend damit ist, dass die Ausgangsfunktion f(x) monoton steigend ist.
Beim Krümmungsverhalten in der Mathematik untersucht man, ob eine Funktion linksgekrümmt oder rechtsgekrümmt ist. In manchmal Fällen kann eine Funktion beide Krümmungen aufweisen. Die Untersuchung kann über die zweite Ableitung durchgeführt werden. Bei der Rechtskrümmung ist die zweite Ableitung an der Stelle x kleiner Null: $f''(x) < 0$. Die Rechtskrümmung wird auch als konkav bezeichnet. Bei der Linkskrümmung ist die zweite Ableitung an der Stelle x größer als Null: $f''(x) > 0$. Die Linkskrümmung wird auch als konvex bezeichnet.
Dazu zeichnet man sich am einfachsten die 2. Ableitung zusammen mit dem Funktionsgraphen in ein Diagramm, um dadurch ablesen zu können, wie sich die Krümmung verhält. Im obigen Beispiel erkennt man, dass die 2. Ableitung zwischen den beiden Nullstellen negativ ist d.h. eine Rechtskrümmung vorliegt, in allen anderen Bereichen dagegen positiv und somit eine Linkskrümmung aufweist.
Die Wertemenge gibt an, welche Werte für f(x) rauskommen können, wenn man jede Zahl aus der Definitionsmenge in die Funktion (als x-Werte) eingesetzt hat. Hier muss man also auf Wissen über die Zahlenmengen (Ganze Zahlen, Natürliche Zahlen, etc) zurück greifen. In unserem Beispiel entspricht der Wertebereich der Menge der Reellen Zahlen. Geschrieben in Mengenschreibweise sieht das Ergebnis dann so aus: $$\mathbb{W} = \mathbb{R}$$
Um sich in dieses umfangreiche System Mathematica einzuarbeiten gibt es verschiedenste Möglichkeiten. Anfänger sind gut beraten, erst mal nicht zu versuchen alle Basiskonzepte auf einmal zu verstehen. Beispielsweise die Aussage: Everything is an expression verwirrt viele zu Beginn. Es handelt sich um einer der elementaren Grundpfeiler von Mathematica. In Mathematica besteht absolut alles – Zahlen, Listen, Formeln, Grafiken, sogar der Programmcode selbst – aus Ausdrücken (expressions).In Mathematica ist ein Ausdruck nicht nur „Text, den man auswertet“, sondern die universelle Datenstruktur – alles von einer Zahl bis zu einem kompletten Notebook ist so aufgebaut.
Dieses fundamentale Konzept in seiner Gesamtheit zu begreifen Bedarf meiner Erfahrung nach Zeit und viel Übung. Aus diesem Grund bietet es sich an, erst mal mit den Kentnissen die man gerade hat, versuchen zu arbeiten und sich immer wieder neuen Herausforderungen zu stellen. Und natürlich auch den Programmcode von anderen zu studieren und so das eigene Wissen zu vertiefen.