Table[ f, {i , m }, {j , n } ]     erzeugt m×n Matrix a mit aij = f(i,j) DiagonalMatrix[ liste ]     erzeugt Diagonalmatrix aus liste IdentityMatrix[ n ]     erzeugt n×n Einheitsmatrix c * a     Multiplikation mit Skalar c (elementweise) a . v     Multiplikation der Matrix a mit Vektor v a . b     Multiplikation der Matrizen a und b Cross[ u , v ]     Kreuzprodukt u ×v der Vektoren u und v Transpose[ a ]     Transponierte aT der Matrix a Inverse[ a ]     Inverse a-1 der n×n Matrix a Det[ a ]     Determinante der Matrix a Tr[ a ]     Spur der Matrix a MatrixPower[ a , n ]     n-te Potenz an der Matrix a MatrixExp[ a ]     Exponentialfunktion exp(a) der Matrix a

In[1]:= u = {u1, u2}; In[2]:= v = {v1, v2}; In[3]:= mat = {{a, b}, {c, d}}; In[4]:= 3 * mat Out[4]= {{3 a, 3 b}, {3 c, 3 d}} In[5]:= u . v Out[5]= u1 v1 + u2 v2 In[6]:= mat . v // MatrixForm Out[6]//MatrixForm= a v1 + b v2 c v1 + d v2 In[7]:= inv = Inverse[mat] d b c a Out[7]= {{------------, -(------------)}, {-(------------), ------------}} -(b c) + a d -(b c) + a d -(b c) + a d -(b c) + a d In[8]:= mat . inv // Simplify // MatrixForm Out[8]//MatrixForm= 1 0 0 1 In[9]:= Det[mat] Out[9]= -(b c) + a d

Eigenvalues[ a ]     Liste der Eigenwerte der Matrix a Eigenvectors[ a ]     Liste der Eigenvektoren der Matrix a LUDecomposition[ a ]     LU-Zerlegung der n×n Matrix a LUBackSubstitution[ data , b ]     löst a ·x = b aus LU-Zerlegung von a

Als Beispiel wollen wir die Konditionszahl ||a|| ·||a-1|| der 5 ×5 Hilbertmatrix bezüglich der 2-Norm ||a||2 = max{ |li| } berechnen, wo li die Eigenwerte der symmetrischen Matrix a darstellen:

In[1]:= h = Table[ 1.0/(i+j-1), {i, 5}, {j, 5} ]; In[2]:= MatrixForm[h] Out[2]//MatrixForm= 1. 0.5 0.333333 0.25 0.2 0.5 0.333333 0.25 0.2 0.166667 0.333333 0.25 0.2 0.166667 0.142857 0.25 0.2 0.166667 0.142857 0.125 0.2 0.166667 0.142857 0.125 0.111111 In[3]:= u = Inverse[h]; In[4]:= MatrixForm[u] Out[4]//MatrixForm= 25. -300. 1050. -1400. 630. -300. 4800. -18900. 26880. -12600. 1050. -18900. 79380. -117600. 56700. -1400. 26880. -117600. 179200. -88200. 630. -12600. 56700. -88200. 44100. In[5]:= rho1 = Max[ Abs[ Eigenvalues[h] ] ] Out[5]= 1.56705 In[6]:= rho2 = Max[ Abs[ Eigenvalues[u] ] ] Out[6]= 304143. In[7]:= cond = rho1 * rho2 Out[7]= 476607.

5   Summen und Produkte

Sum[ f, {i, imin, imax } ]     Summe åi=iminimax f Sum[ f, {i, imin, imax, di } ]     Schrittweite di für i Sum[ f, {i, imin, imax }, {j, jmin, jmax } ]     åi=iminimax  åj=jminjmax  f Product[ f, {i, imin, imax } ]     Produkt Õi=iminimax f

Die Summe åi=15 xi / i  .

In[1]:= Sum[ x^i/i, {i, 1, 5} ] 2 3 4 5 x x x x Out[1]= x + -- + -- + -- + -- 2 3 4 5

Das Produkt Õi=13 (x + i)  .

In[2]:= Product[x + i, {i, 1, 3}] Out[2]= (1 + x) (2 + x) (3 + x)

Mathematica liefert das exakte Resultat für diese Summe.

In[3]:= Sum[ 1/i^4, {i, 1, 15} ] 18250192489014819937873 Out[3]= ----------------------- 16863445484161436160000

Eine numerische Näherung erhält man mit der Funktion N[].

In[4]:= N[%] Out[4]= 1.08223

Die Doppelsumme åi=12 åj=1i xi yj  .

In[5]:= Sum[ x^i y^j, {i, 1, 2}, {j, 1, i}] 2 2 2 Out[5]= x y + x y + x y

Die Summe åi=1n i2 wird symbolisch ausgewertet.

In[6]:= Sum[ i^2, {i, n} ] n (1 + n) (1 + 2 n) Out[6]= ------------------- 6

Mathematica kennt auch die Exponentialreihe ån=0¥ xn / n!  .

In[10]:= Sum[ x^n / n!, {n, 0, Infinity} ] x Out[10]= E

6   Grenzwerte

Limit[ f, x -> a ]     Grenzwert lim x  ® a f(x) Limit[ f, x -> a, Direction -> 1 ]     Linksseitiger Grenzwert     lim x  ® a- f(x) Limit[ f, x -> a, Direction -> -1 ]     Rechtsseitiger Grenzwert     lim x  ® a+ f(x) NLimit[ f, x -> a ]     lim x  ® a f(x) numerisch

Der Grenzwert lim x ® 0[1/x]. Normalerweise wird der rechtsseitige Grenzwert berechnet.

In[1]:= Limit[ 1/x, x -> 0 ] Out[1]= Infinity In[2]:= Limit[ 1/x, x -> Infinity ] Out[2]= 0

Die linksseitigen Grenzwerte lim x ® 0-[1/x]  und lim x ® p/2-tanx  .

In[3]:= Limit[ 1/x, x -> 0, Direction -> 1 ] Out[3]= -Infinity In[4]:= Limit[ Tan[x], x -> Pi/2, Direction -> 1 ] Out[4]= Infinity

Limit[] arbeitet symbolisch und kann auch Argumente mit unbestimmten Parametern behandeln.

In[5]:= Limit[ (1 + 1/x)^x, x -> Infinity ] Out[5]= E In[6]:= Limit[ x^n / E^x, x -> Infinity ] Out[6]= 0

Bei lim x ® ¥(ex/x!)   scheiterte Mathematica bis zur Version 4. Ab Version 5 wird der korrekte symbolische Wert 0 zurückgegeben.

In[7]:= Limit[ E^x / x!, x -> Infinity ] Series::esss: Essential singularity encountered ...

Jedenfalls läßt sich dieser Grenzwert numerisch berechnen, wenn das Zusatzpaket NumericalMath`NLimit` geladen wird.

In[8]:= Needs[ "NumericalMath`NLimit`"] In[9]:= NLimit[ E^x / x!, x -> Infinity ] Out[9]= 0.

7   Vergleichsoperatoren und logische Operatoren

Mit Vergleichsoperatoren werden zwei (oder mehrere) Ausdrücke verglichen. Das Ergebnis eines solchen logischen Ausdrucks kann wahr oder falsch sein. In Mathematica werden dafür die Symbole True und False verwendet. Für den Fall, daß der Wahrheitswert nicht festgestellt werden kann, bleibt der gesamte logische Ausdruck unausgewertet. Vergleichsoperatoren werden in Mathematica so geschrieben wie in der Programmiersprache C. ls == rs     Test auf Gleichheit ls != rs     Ungleichheit ls < rs     kleiner ls <= rs     kleiner oder gleich ls > rs     größer ls >= rs     größer oder gleich

Dieser logische Ausdruck kann sofort ausgewertet werden.

In[1]:= 2 < 5 Out[1]= True

Auch ohne konkreten Wert von x muß x gleich sich selbst sein.

In[2]:= x == x Out[2]= True

Da x und y noch keine Werte haben, kann der Wahrheitswert dieses Ausdrucks nicht festgestellt werden.

In[3]:= x == y Out[3]= x == y

Logische Ausdrücke können weiter mit logischen Operatoren verknüpft werden, um kompliziertere logische Ausdrücke zu bilden. Auch hier ist die Notation gleich wie in der Programmiersprache C. !p     logische Negation p && q && ...     UND-Verknüpfung p || q || ...     ODER-Verknüpfung If[p, a, b]     wenn p dann a , sonst b

Bei der UND-Verknüpfung müssen alle Teile True ergeben, damit das Resultat True ist.

In[4]:= 0 <= 2 && 2 < 5 Out[4]= True

Bei der ODER-Verknüpfung muß mindestens ein Ausdruck True ergeben. Da die Ausdrücke von links nach rechts ausgewertet werden, und da 2 < 5 bereits True ist, kommt es gar nicht mehr auf den zweiten an.

In[5]:= 2 < 5 || x == y Out[5]= True

Da der logische Ausdruck 5 > 4 den Wert True hat, wird 1 zurückgegeben.

In[6]:= If[ 5 > 4, 1, 2 ] Out[6]= 1

8   Definition von Funktionen

Mathematica besitzt bereits eine Fülle von eingebauten Funktionen (Abs[], Exp[], Sin[], Expand[], usw.). Daneben gibt es auch die Möglichkeit, eigene Funktionen zu definieren. Zum Beispiel kann die Definition einer Funktion, welche ihr Argument quadriert, in Mathematica so aussehen: f[x_] := x^2 Funktionsargumente werden in eckigen Klammern angegeben, der Operator für die Definition ist := (ohne Leerzeichen zwischen : und =). Das Funktionsargument x_ steht als Platzhalter für ein beliebiges Muster, d.h. für ``irgend etwas'', das man auf der rechten Seite mit dem Namen x ansprechen möchte. Im allgemeinen wird in Mathematica ein beliebiges Muster, d.h. ein beliebiger Ausdruck, durch einen Unterstrich _ ausgedrückt. Die Schreibweise x_ bedeutet, daß dieses ``Irgendetwas'' mit dem Namen x versehen wird, unter dem es dann auf der rechten Seite angesprochen werden kann.

Die Funktion f wird definiert und die für das Symbol f definierten Regeln werden angezeigt: f quadriert ihr Argument.

In[1]:= f[x_] := x^2 In[2]:= ?f Global`f f[x_] := x^2

Für Zahlen als Argumente von f wird das Resultat sofort ausgerechnet.

In[3]:= f[2] Out[3]= 4 In[4]:= f[I] Out[4]= -1

Rein symbolische Argumente werden nach der Anwendung von f nicht mehr weiter vereinfacht.

In[5]:= f[a + b] 2 Out[5]= (a + b) In[6]:= f[a + b] // Expand 2 2 Out[6]= a + 2 a b + b

Integrate[] könnte ebensogut mit f[z] als Integrand und z als Integrationsvariable geschrieben werden.

In[7]:= Integrate[f[t], t] 3 t Out[7]= -- 3

Eine Funktion mit 2 Argumenten. Mathematica merkt sich beide Definitionen von f und unterscheidet sie anhand der Argumente. Eine neue Definition überschreibt eine bestehende nur, wenn die linke Seite dieselbe ist.

In[8]:= f[x_, y_] := Exp[-x^2-y^2] In[9]:= f[a, b] 2 2 -a - b Out[9]= E

Die symbolische Auswertung des Mehrfachintegrals ò-¥+¥ ò-¥+¥ e-x2-y2dxdy.

In[10]:= Integrate[f[x, y], {x, -Infinity, Infinity}, {y, -Infinity, Infinity}] Out[10]= Pi

Mathematica kennt zwei Arten von Definitionen (Zuweisungen): ls = rs     sofortige Definition ls := rs     verzögerte Definition Der Unterschied besteht darin, wann die rechte Seite ausgewertet wird. Bei der sofortigen Definition wird die rechte Seite sofort beim Aufstellen (Einlesen) der Definition ausgewertet und dem Symbol auf der linken Seite zugewiesen. Bei der verzögerten Definition erfolgt die Auswertung der rechten Seite erst dann (und zwar jedesmal neu), wenn das Symbol auf der linken Seite verwendet wird.

Verzögerte Definition von f. Die rechte Seite bleibt zunächst unausgewertet.

In[1]:= f[x_] := Expand[(1 + x)^2] In[2]:= ?f Global`f f[x_] := Expand[(1 + x)^2]

Sofortige Definition von g. Die rechte Seite wird sofort ausgewertet und das Resultat von Expand als Funktionsvorschrift gespeichert.

In[3]:= g[x_] = Expand[(1 + x)^2] 2 Out[3]= 1 + 2 x + x In[4]:= ?g Global`g g[x_] = 1 + 2*x + x^2

Erst bei der Verwendung von f wird Expand ausgeführt.

In[5]:= f[y + 2] 2 Out[5]= 9 + 6 y + y

Bei der Funktion g wird das Argument in die bereits expandierte Form eingesetzt.

In[6]:= g[y + 2] 2 Out[6]= 1 + 2 (2 + y) + (2 + y)

Sofortige Definitionen (=) und verzögerte Definitionen (:=) können auch für Wertzuweisungen an Variablen verwendet werden:

Die Funktion Random[] gibt eine Pseudozufallszahl vom Typ Real zwischen 0 und 1 zurück.

In[7]:= r1 = Random[] Out[7]= 0.993679 In[8]:= r2 := Random[]

Wiederholter Aufruf von r1 liefert immer dieselbe Zufallszahl. Bei jeder Verwendung der Variablen r2 wird die rechte Seite ihrer Definition erneut ausgewertet und daher jedesmal eine andere Zufallszahl erzeugt.

In[9]:= {r1, r2} Out[9]= {0.993679, 0.202585} In[10]:= {r1, r2} Out[10]= {0.993679, 0.152187}

Faustregeln für Definitionen: Sofortige Definitionen mit = sind dort sinnvoll, wo man ein Symbol (oder ein Muster) als Abkürzung für einen festen Wert definieren will. Falls auf der rechten Seite der Definition bei der Anwendung noch etwas ausgerechnet werden muß, so verwendet man eine verzögerte Definition mit :=. Funktionen sollten daher fast immer mit verzögerten Definitionen formuliert werden, für Konstanten können sofortige Definitionen gegeben werden.

Mathematica kennt kein eigenes Kommando, um Funktionen stückweise zu definieren. Stückweise definierte Funktionen werden durch mehreren Regeln mit nachgestellten Bedingungen an ihre Gültigkeit definiert. Definitionen, die nur unter bestimmten Bedingungen gelten, werden so aufgestellt: ls := rs    /;    lausdr Die Einschränkung wird mit dem Operator /; (``unter der Bedingung, daß'') vorgenommen. lausdr ist ein logischer Ausdruck. Die Definition auf der linken Seite wird nur dann verwendet, wenn dieser Ausdruck den Wert True liefert.

So kann eine Sprungfunktion stückweise definiert werden.

In[1]:= step[x_] := 0 /; x < 0 In[2]:= step[x_] := 1 /; x >= 0 In[3]:= {step[-1], step[1]} Out[3]= {0, 1}

Alternativ kann die obige Sprungfunktion auch so definiert werden.

In[4]:= step[x_] := If[x >= 0, 1, 0] In[5]:= {step[-1], step[1]} Out[5]= {0, 1}

In der Standardform der Funktionsanwendung in Mathematica stehen die Argumente in eckigen Klammern hinter dem Funktionsnamen. Bei Funktionen mit einem Argument sind noch zwei weitere Notationen möglich: In der Postfixform werden Funktionen mit dem Operator // von rechts auf einen Ausdruck angewendet. In der Präfixform werden Funktionen mit dem Operator @ von links auf einen Ausdruck angewendet (dabei muß der Ausdruck i.a. in runden Klammern stehen): f[x, y]     Standardform für f[x, y] f @ x     Präfixform für f[x] x // f     Postfixform für f[x]

Anwendung der Funktion Expand[] auf das Argument (a+b)^2 in Standardform, Präfixform (Argument in runden Klammern!) und Postfixform. Alle drei Formen sind vollständig äquivalent.

In[1]:= Expand[(a+b)^2] 2 2 Out[1]= a + 2 a b + b In[2]:= Expand @ ((a+b)^2) 2 2 Out[2]= a + 2 a b + b In[3]:= (a+b)^2 // Expand 2 2 Out[3]= a + 2 a b + b

Mathematica stellt für Funktionen noch eine spezielle Konstruktion zur Verfügung, die in den meisten traditionellen Programmiersprachen fehlt, nämlich sogenannte reine oder anonyme Funktionen (pure functions). Die Idee ist dabei, Funktionen, die nur einmal benötigt werden, kompakt darstellen zu können, ohne sie vorher mit einem eigenen Symbol definieren zu müssen. Bei einer reinen Funktion wird nur angegeben, welche Operationen ausgeführt werden sollen und wo die Argumente stehen sollen. Reine Funktionen werden zum Beispiel als Ergebnis beim symbolischen Lösen von Differentialgleichungen mit DSolve[] in Form einer Liste von Ersetzungsregeln für die Lösungsfunktion zurückgegeben.

Um eine gewöhnliche Funktion verwenden zu können, muß sie zuerst definiert werden.

In[1]:= f[x_] := x^2 In[2]:= f[5] Out[2]= 25

Reine Funktionen werden mit Function[] geschrieben, in den Argumenten steht zuerst der Name der Hilfsvariablen (Platzhalter), dann die Operationen, die damit ausgeführt werden sollen. Dieser Ausdruck steht für die Funktion selbst, deren Wert an der Stelle x gleich x^2 ist.

In[3]:= Function[x, x^2] 2 Out[3]= Function[x, x ]

Wird eine reine Funktion auf ein Argument angewendet, so wird dieses für x eingesetzt und die Funktionsvorschrift dafür ausgewertet. Damit ist eine vorhergehende Definition nicht notwendig.

In[4]:= Function[x, x^2][5] Out[4]= 25

Man kann auch die Ableitung dieser Funktion bestimmen. Das Ergebnis ist eine Funktion, die ihr Argument mit 2 multipliziert.

In[5]:= Function[x, x^2]' Out[5]= Function[x, 2 x]

Der Name x für den Platzhalter in einer reinen Funktion ist überflüssig. Deshalb kann man ihn durch ein # ersetzen und nur noch die Funktionsdefinition schreiben.

In[6]:= Function[#^2][5] Out[6]= 25

In einer noch kürzeren Schreibweise wird Function[] weggelassen und das Ende der reinen Funktion mit einem & markiert.

In[8]:= #^2 & [5] Out[8]= 25

Der gleiche Ausdruck in Präfixnotation und in Postfixnotation.

In[9]:= #^2 & @ 5 Out[9]= 25 In[10]:= 5 // #^2 & Out[10]= 25

Bei reinen Funktionen mit mehreren Argumenten werden diese entweder in eine Liste gesetzt (Schreibweise mit Function[]) oder mit #1, #2, ... bezeichnet (Kurzschreibweise).

In[11]:= Function[{x, y}, Sqrt[x^2 + y^2]][3,4] Out[11]= 5 In[12]:= Sqrt[#1^2 + #2^2] & [3,4] Out[12]= 5

Man kann natürlich auch Definitionen mit reinen Funktionen schreiben, hier am Beispiel des geometrischen Mittels dreier Zahlen.

In[13]:= gm1 = (#1 #2 #3)^(1/3) &; In[14]:= gm1[a, b, c] 1/3 Out[14]= (a b c)

In Mathematica werden viele eingebaute Funktionen automatisch auf die Elemente von Listen angewendet. Diese Funktionen besitzen das Attribut Listable. Benutzerdefinierte Funktionen sind im allgemeinen nicht Listable und werden daher nicht automatisch auf Listenelemente abgebildet.

In[1]:= liste = {a, b, c} Out[1]= {a, b, c}

Die Funktion Sin[] wird automatisch auf die Elemente von {a, b, c} angewendet.

In[2]:= Sin[liste] Out[2]= {Sin[a], Sin[b], Sin[c]}

Die Funktion g wirkt nicht separat auf jedes Listenelement. g[liste] ergibt 2 anstelle von {2, 2, 2}.

In[3]:= g[x_] := 2 In[4]:= g[liste] Out[4]= 2

Deshalb gibt es in Mathematica die Möglichkeit, Funktionen mit nur einem Argument, die nicht Listable sind, auf jedes Element einer Liste anzuwenden: Map[f, {a, b, c, ¼ }]     ergibt {f[a], f[b], f[c], ¼ } f /@ {a, b, c, ¼ }     Kurzform in Infixnotation

Map[] wendet g auf jedes Listenelement an.

In[5]:= Map[g, liste] Out[5]= {2, 2, 2}

Kurzschreibweise für Map[g, liste].

In[6]:= g /@ liste Out[6]= {2, 2, 2}

Manchmal ist es notwendig, die Elemente einer Liste als Argumente einer Funktion zu verwenden. Dafür stellt Mathematica die Funktion Apply[] zur Verfügung: Apply[f, {a, b, c, ¼ }]     ergibt f[a, b, c, ¼ ] f @@ {a, b, c, ¼ }     Kurzform in Infixnotation

Die Elemente der Liste {a, b, c} werden durch die Funktion Apply[] als Argumente von f verwendet.

In[7]:= Apply[f, liste] Out[7]= f[a, b, c] In[8]:= f @@ liste Out[8]= f[a, b, c]

Die Additionsfunktion Plus[] wird normalerweise mit dem Operator + geschrieben. Wird sie mit Apply[] auf eine Liste angewendet, erhält man die Summe der Elemente.

In[9]:= Apply[Plus, liste] Out[9]= a + b + c In[10]:= Plus @@ liste Out[10]= a + b + c

Analog erhält man mit der Multiplikationsfunktion Times[] das Produkt der Elemente.

In[11]:= Apply[Times, liste] Out[11]= a b c In[12]:= Times @@ liste Out[12]= a b c

Damit läßt sich eine Variante des geometrischen Mittels als reine Funktion definieren, welche eine Liste mit beliebiger Länge als Argument verwendet. Length[liste] liefert die Anzahl der Elemente von liste.

In[13]:= gm2 = (Times@@#)^(1/Length[#])&; In[14]:= gm2[{a, b, c, d, e}] 1/5 Out[14]= (a b c d e)

Eine Anmerkung zur Arbeitsweise von Mathematica

Der grundlegende (und einzige) Datentyp von Mathematica ist der Ausdruck (expression ): Jede gültige Mathematica-Anweisung ist ein Ausruck. Diese Struktur ist dieselbe wie in der Programmiersprache LISP. Intern wird jeder Ausdruck dargestellt als h [ e1, e2, ¼ , en ] , wobei h und die ei selbst wieder Ausdrücke sind. h heißt der Kopf (head ) des Ausdrucks, die ei sind die Elemente . In[1]:= x + 2*y + z^2 // FullForm Out[1]//FullForm= Plus[x, Times[2, y], Power[z, 2]] In[2]:= Head[%1] Out[2]= Plus In[3]:= Part[%1, 2] Out[3]= 2 y Formal ist ein Ausdruck entweder ein Atom oder ein zusammengesetzter Ausdruck . Von den Atomen gibt es nur 3 Arten: Symbole , Strings (Zeichenketten) und Zahlen (ganze Zahlen, rationale Zahlen, Gleitpunktzahlen und komplexe Zahlen). Atome haben ebenfalls einen Kopf, der den Typ des Atoms beschreibt: In[4]:= Map[ Head, {x, "hallo", 3, 2/3, 3.14, 2 + 3*I} ] Out[4]= {Symbol, String, Integer, Rational, Real, Complex} Die grundlegende Operation von Mathematica ist die Auswertung (evaluation ) von Ausdrücken. Dazu werden alle benutzerdefinierten und internen Definitionen (Transformationsregeln) auf einen Ausdruck in einer vorgegebenen Reihenfolge solange angewendet, bis sich der Ausdruck nicht mehr verändert: In[1]:= a = 2; b = 3; a*x + b // Trace Out[1]= {{{a, 2}, 2 x}, {b, 3}, 2 x + 3, 3 + 2 x}

9   Graphik

9.1   Graphen von Funktionen

Plot[f, {x, xmin, xmax}]     zeichnet f als Funktion von x     im Bereich von xmin bis xmax Plot[{f1, f2, ¼ }, {x, xmin, xmax}]     zeichnet mehrere Funktionen     f1, f2, ¼ gleichzeitig Plot[Evaluate[f], {x, xmin, xmax}]     wertet f vor dem Einsetzen     von Zahlenwerten aus

So zeichnet man den Graphen der Funktion sinx im Bereich von 0 bis 2p. Die Ausgabezeile -Graphics- steht für die Mathematica-interne Darstellung eines zweidimensionalen Graphikobjekts. Sie kann durch die Angabe eines Strichpunktes am Ende von Plot[] unterdrückt werden.

In[1]:= Plot[Sin[x], {x, 0, 2Pi}] Out[1]= -Graphics-

Wenn mehrere Funktionen gleichzeitig dargestellt werden sollen, müssen diese in einer Liste angegeben werden.

In[2]:= Plot[{Sin[3x], Sin[5x]}, {x, 0, Pi}];

Wenn eine Funktion Singularitäten aufweist, schneidet Mathematica den Zeichenbereich ab und versucht nicht, alle Funktionswerte darzustellen.

In[3]:= Plot[Tan[x], {x, 0, 2Pi}];

Beim Plot[]-Kommando werden zunächst die Zahlenwerte für die x-Achse erzeugt, und dann erst wird jeder dieser Werte in den Ausdruck f eingesetzt, der dabei immer wieder neu ausgewertet wird. Das kann bei komplizierten Ausdrücken sehr zeitaufwendig sein oder sogar zu Fehlermeldungen und einer leeren Graphik führen, zum Beispiel wenn f ein Ausdruck ist, der eine Tabelle von Funktionen erzeugt. Deshalb sollte nach Möglichkeit das Argument f von Plot[] mit Hilfe von Evaluate[] ausgewertet werden. Dieses Kommando erzwingt die Auswertung des Ausdrucks f, bevor dieser an Plot[] weitergegeben wird: In[4]:= Plot[ Evaluate[ Table[Sin[n x]/n, {n, 1, 5}] ], {x, 0, 2Pi} ]; Ohne Evaluate[] würde jedem Datenpunkt x eine Liste mit 5 Zahlenwerten zugeordnet, und nicht eine Liste von 5 Funktionen, die Mathematica zeichnen könnte.

Das Aussehen einer mit dem Plot[]-Kommando erzeugten Graphik kann durch Angabe von Optionen in verschiedener Weise verändert werden. Optionen werden als Ersetzungsregeln in der Form Optionsname -> Wert im Plot[]-Kommando angegeben. Für jede Option sind Vorgabewerte (Defaultwerte) eingestellt, sodaß der Entwurf einer Graphik üblicherweise sehr rasch gelingt. Hier werden exemplarisch nur die gängigsten Optionen besprochen. Eine Liste aller Optionen für das Plot[]-Kommando und deren Defaulteinstellungen erhält man mit Options[Plot], eine genaue Beschreibung aller Optionen findet man in der elektronischen Dokumentation (im Help-Menü der graphischen Benutzeroberfläche unter Find in Help Browser nach Eingabe von Plot).

AspectRatio -> Automatic     skaliert beide Achsen gleich -> 1     liefert eine quadratische Graphik Axes -> False     unterdrückt die Achsen AxesLabel -> {"xlabel", "ylabel"}     Achsenbeschriftungen DisplayFunction -> Identity     unterdrückt die Graphikausgabe -> $DisplayFunction     stellt sie wieder her Frame -> True     erzeugt einen Rahmen FrameLabel -> {"u", "l", "o", "r"}     Rahmenbeschriftungen GridLines -> Automatic     zeichnet ein Gitter PlotLabel -> {"label"}     ergibt einen Titel PlotPoints -> n     Minimalanzahl von Stützpunkten PlotRange -> All     voller Wertebereich für x, y PlotStyle -> {{s1}, {s2}, ¼ }     Stiloptionen (z.B. Linienstärke),     zyklisch bei mehreren Kurven

In[5]:= Plot[ Sin[x^2], {x, 0, Sqrt[2Pi]}, AspectRatio -> Automatic, Frame -> True, FrameLabel -> {"x", "Sin[x^2]"}, GridLines -> Automatic, PlotStyle -> Thickness[0.01] ];

Stiloptionen: Die Darstellung von Linien und Kurven wird mit dem Kommando Thickness[] für die Linienbreite und Dashing[] für gestrichelte Linien gesteuert. Mit Thickness[breite] wird die Linienbreite eingestellt. Dashing[{l1, l2, ¼ }] gibt die Längen an, über die eine Linie durchgezogen bzw. unterbrochen werden soll. Die Angaben werden zyklisch wiederholt. Linienbreiten und Längen werden als Bruchteile der Breite der Graphik angegeben; die Defaulteinstellung für Strichbreiten ist 0.004 für 2D-Graphiken. Die beiden wichtigsten Kommandos zur Farbeinstellung lauten RGBColor[rot, grün, blau] und GrayLevel[n], wobei der Wertebereich für die Parameter zwischen 0 und 1 liegt. Für RGBColor[0,0,0] bzw. GrayLevel[0] erhält man jeweils die Farbe schwarz. Daneben gibt es noch das Kommando Hue[farbton, sättigung, helligkeit] zur Farbeinstellung im HSV-Farbmodell (hue, saturation, value bzw. brightness). Für farbton zwischen 0 und 1 wird der Farbkreis von rot, gelb, grün, blau wieder nach rot durchlaufen. Bei der Kurzform Hue[farbton] sind Sättigung und Helligkeit jeweils mit 1 voreingestellt.

In[6]:= Plot[ {x, x^2, x^3}, {x, 0, 3}, PlotStyle -> {{}, Dashing[{0.02}], Thickness[0.01]} ];

Die erste Kurve wird jetzt mit der Defaulteinstellung gezeichnet ({}), die zweite strichliert (Dashing[]), die dritte dicker als üblich (Thickness[]).

In[7]:= Plot[ {Sin[x], Sin[2x], Sin[3x]}, {x, 0, Pi}, PlotStyle -> { {Thickness[0.01], RGBColor[1,0,0]}, {Thickness[0.01], RGBColor[0,1,0]}, {Thickness[0.01], RGBColor[0,0,1]}} ];

Plot3D[ f, {x, xmin, xmax}, {y, ymin, ymax} ] Plot3D[ {f, farbe}, {x, xmin, xmax}, {y, ymin, ymax} ]

Das Kommando Plot3D[] stellt eine Funktion f von zwei Variablen x und y als Fläche im Raum dar. Dabei wird der rechteckige Definitionsbereich [xmin, xmax]×[ymin, ymax] als Grundfläche eines Quaders und der Wertebereich in vertikaler Richtung abgebildet. Die Farbgebung kann durch eine zweite Funktion farbe[x, y] gesteuert werden. Die Option PlotPoints -> n stellt die Zahl der Rasterpunkte pro Richtung ein (default: 15) und steuert damit die Auflösung. Weitere wichtige Optionen: Boxed -> False deaktiviert das Zeichnen eines umschreibenden Quaders (default: True). Mesh -> False unterdrückt das Zeichnen von Gitterlinien auf der Fläche (default: True). BoxRatios -> {nx, ny, nz} bestimmt die Proportionen einer 3D-Graphik; mit der Einstellung {1, 1, 1} wird die Graphik in einem Würfel angezeigt, mit der Defaulteinstellung von {1, 1, 0.4} in einem flachen, quadratischen Quader. Mit der Einstellung ViewPoint -> {x, y, z} bestimmt man den Ort, von dem aus die Graphik betrachtet wird in einem eigenen, objektunabhängigen Koordinatensystem. Die Defaulteinstellungen sind {1.3, -2.4, 2}. Viele Optionen von Plot3D[] sind analog zu denen von Plot[], wie etwa AspectRatio, Axes, AxesLabel, PlotLabel, PlotPoints und PlotRange.

In[8]:= Plot3D[ Cos[Sqrt[x^2 + y^2]], {x, -3Pi, 3Pi}, {y, -3Pi, 3Pi}] Out[8]= -SurfaceGraphics- Die Ausgabezeile -SurfaceGraphics- steht für ein Graphikobjekt einer 3D-Oberflächengraphik.

In[9]:= z = Cos[Sqrt[x^2 + y^2]]; In[10]:= Plot3D[ {z, GrayLevel[Abs[z]*0.5+0.4]}, {x, -3Pi, 3Pi}, {y, -3Pi, 3Pi}, Axes -> None, Mesh -> False, PlotPoints -> 60 ];

Manchmal ist eine andere Darstellung von Funktionen zweier Variablen hilfreich. Mit ContourPlot[] betrachtet man den rechteckigen Definitionsbereich von oben und zeichnet die Höhenschichtlinien der Funktion. Die Option Contours -> n gibt die Anzahl der Höhenlinien an, ContourShading -> False verhindert die Grauschattierung, ContourLines -> False unterdrückt das Zeichnen der Höhenlinien. DensityPlot[] bildet die Funktionswerte auf Grau- oder Farbstufen in einem quadratischen Gitter ab.

In[11]:= z = (x-1)(x+2)(y-2)(y+2); In[12]:= ContourPlot[ z, {x, -3, 3}, {y, -3, 3}, PlotPoints -> 40] Out[12]= -ContourGraphics- -ContourGraphics- steht für ein Graphikobjekt einer 2D-Rastergraphik mit Höhenschichtlinien.

In[13]:= ContourPlot[ z, {x, -3, 3}, {y, -3, 3}, Contours -> 30, ContourShading -> False, PlotPoints -> 40 ];

In[14]:= DensityPlot[ z, {x, -3, 3}, {y, -3, 3}, Mesh -> False, PlotPoints -> 60] Out[14]= -DensityGraphics- Die Ausgabezeile -DensityGraphics- steht für ein Graphikobjekt einer 2D-Rastergraphik.

9.2   Parametrische Kurven und Flächen

ParametricPlot[ {fx, fy}, {t, tmin, tmax} ] ParametricPlot3D[ {fx, fy, fz}, {t, tmin, tmax} ] ParametricPlot3D[ {fx, fy, fz}, {u, umin, umax}, {v, vmin, vmax} ]

Eine parametrische Kurve in der Ebene: In[1]:= ParametricPlot[ {Sin[2t], Sin[3t]}, {t, 0, 2Pi}, AspectRatio -> Automatic ]; Es können die gleichen Optionen wie bei Plot[] verwendet werden.

Eine parametrische Kurve im Raum: In[2]:= ParametricPlot3D[ {Sin[t], Cos[t], t/6}, {t, -2Pi, 2Pi}, Axes -> False ] Out[2]= -Graphics3D- Die Ausgabezeile -Graphics3D- steht für das Graphikobjekt einer allgemeinen 3D-Graphik, die aus einzelnen Polygonen zusammengesetzt ist.

Eine parametrische Fläche im Raum: In[3]:= ParametricPlot3D[ {Cos[u] (3 + Cos[v]), Sin[u] (3 + Cos[v]), Sin[v]}, {u, 0, 2Pi}, {v, 0, 2Pi}, Axes -> False, Boxed -> False ];

9.3   Graphische Darstellung diskreter Daten

Diskrete Daten können entweder von Mathematica selbst stammen (etwa aus einem Table[]-Kommando), oder von externen Dateien mit ReadList[] eingelesen worden sein. In beiden Fällen liegen die Daten als (verschachtelte) Listen vor. Zu fast allen Graphik-Kommandos existieren auch Varianten, um solche Datenlisten darzustellen:

ListPlot[ {y1, y2, ¼ } ]     zeichnet y1, y2, ¼ mit     x-Werten von 1, 2, ¼ ListPlot[{{x1, y1}, {x2, y2}, ¼ }]     zeichnet die Punkte     (x1,y1), (x2,y2), ¼ ListPlot3D[ {{z11, z12, ¼ },     zeichnet eine 3D-Fläche {z21, z22, ¼ }, ¼ } ]     mit z-Werten aus der       angegebenen 2D-Liste ScatterPlot3D[ {{x1, y1, z1},     zeichnet eine 3D-Punktgraphik, {x2, y2, z2} ¼ } ]     braucht Graphics`Graphics3D`

In[1]:= data = Table[i^2, {i, 10}]; In[2]:= ListPlot[ data, PlotStyle -> PointSize[0.02] ]; Die Option PlotStyle -> PointSize[n] stellt die Punktgröße n relativ zur Gesamtgraphik ein.

In[3]:= ListPlot[ data, PlotJoined -> True ]; Die Option PlotJoined -> True verbindet die Punkte durch einen Linienzug.

In[4]:= data = Table[ {i, Sqrt[i]}, {i, 0, 0.5, 0.025} ]; In[5]:= ListPlot[data]; Das erste Element jeder Teilliste wird hier als x-Koordinate verwendet.

In[6]:= data = Table[ Sin[x] + Sin[y], {x, 0, 3Pi, Pi/5}, {y, 0, 3Pi, Pi/5} ]; In[7]:= ListPlot3D[data]; Die Graphik wird unabhängig von der Zahl der Koordinatenpunkte in x- und y-Richtung auf einen quadratischen Bereich abgebildet.

In[8]:= Needs["Graphics`Graphics3D`"]; In[9]:= data = Table[ {t/10, Sin[t], Cos[t]}, {t, 0, 10Pi, Pi/30} ]; In[10]:= ScatterPlot3D[data]; Durch die Option PlotJoined -> True werden die Punkte durch Linien miteinander verbunden.

Das Kommando ReadList[] eignet sich besonders zum Lesen von Zahlenwerten aus ASCII-Dateien, die nicht von Mathematica stammen:

ReadList["file", Number]     liest Zahlen aus file in       eindimensionale Liste ReadList["file", Number,     Daten werden zeilenweise RecordLists -> True]     zu Teillisten gruppiert

Das Kommando !!file zeigt die ASCII-Datei mit dem Namen file am Schirm an.

In[11]:= !!file1.dat 1 1 2 4 3 9

Liest die in file1.dat enthaltenen Zahlen, die durch Kommas, Leerzeichen oder Zeilenumbrüche getrennt sein dürfen, und gibt sie als Liste zurück.

In[11]:= ReadList["file1.dat", Number] Out[11]= {1, 1, 2, 4, 3, 9}

Mit der Option RecordLists -> True werden die Daten zeilenweise zu Teillisten gruppiert.

In[12]:= ReadList["file1.dat", Number, RecordLists -> True ] Out[12]= {{1, 1}, {2, 4}, {3, 9}}

9.4   Spezialkommandos

9.4.1   Logarithmische Achsenskalierung

Im Mathematica-Paket Graphics`Graphics` findet man unter anderem Kommandos zur logarithmischen Skalierung jeweils einer oder beider Koordinatenachsen. Alle diese Kommandos stehen auch in einer ListPlot[]-Version zur Verfügung.

LogPlot[ f, {x, xmin, xmax} ]     y-Achse logarithmisch LogLinearPlot[ f, {x, xmin, xmax} ]     x-Achse logarithmisch LogLogPlot[ f, {x, xmin, xmax} ]     beide Achsen logarithmisch

In[1]:= Needs["Graphics`Graphics`"]; In[2]:= Plot[E^x, {x, 0, 10}];

In[3]:= LogPlot[E^x, {x, 0, 10}];

In[4]:= LogLinearPlot[Sin[x], {x, 0.1, 100}];

In[5]:= LogLogPlot[E^x, {x, 0.1, 10}];

9.4.2   Graphiken kombinieren

Graphiken werden Mathematica-intern nicht als Bilder (Rastergraphiken), sondern als eine Folge von Kommandos mit zugehörigen Daten und Optionen dargestellt. Deshalb können Graphiken, wie alle anderen Mathematica-Ausdrücke, in Variablen gespeichert und mit dem Show[]-Kommando später mit zusätzlichen bzw. veränderten Optionen nochmals angezeigt werden. Außerdem können mit dem Show[]-Kommando mehrere Graphiken gleichen Typs gemeinsam angezeigt werden; Mathematica paßt dabei die Wertebereiche für die Koordinatenachsen so an, daß alle vorhandenen Informationen dargestellt werden.

Show[g]     Graphik g anzeigen Show[g, option -> value]     g mit geänderten Optionen anzeigen Show[g1, g2, ¼ ]     g1, g2, ¼ gemeinsam anzeigen

In[1]:= g1 = Plot[Sin[x], {x, 0, 2Pi}];

In[3]:= g3 = Show[g1, g2];

In[2]:= g2 = ListPlot[ Table[{i, Sin[i] + Random[Real, {-0.1, 0.2}]}, {i, 0, 2Pi, 0.1}] ];

Mit dem Kommando Show[ GraphicsArray[ {{g1, g2}, {g3, g4}}]] können einzelne Graphiken auch verschiedenen Typs zeilenweise in einem Raster angeordnet werden. Die Einzelgraphiken werden zeilenweise in einer zweidimensionalen Liste übergeben. In[4]:= g4 = Plot3D[ Cos[x y], {x, 0, 2Pi}, {y, 0, Pi}, DisplayFunction -> Identity ]; Durch die Option DisplayFunction -> Identity wird die Graphik zwar berechnet, aber nicht angezeigt.

In[5]:= Show[ GraphicsArray[{{g1, g2}, {g3, g4}}] ] Out[5]= -GraphicsArray- Mathematica erzeugt ein Graphikobjekt vom Typ ``Liste von Graphiken verschiedenen Typs''.

9.4.3   Vektorfelder

Die beiden Mathematica-Pakete Graphics`PlotField` und Graphics`PlotField3D` beinhalten Kommandos zur Darstellung von zwei- bzw. dreidimensionalen vektoriellen Funktionen (Vektorfeldern) (fx(x,y),fy(x,y)) bzw. (fx(x,y,z),fy(x,y,z),fz(x,y,z)).

PlotVectorField[ {fx, fy}, {x, xmin, xmax}, {y, ymin, ymax} ] PlotVectorField3D[ {fx, fy, fz}, {x, xmin, xmax}, {y, ymin, ymax}, {z, zmin, zmax} ]

Die Komponenten der Vektorfunktion werden im ersten Parameter als Liste angegeben. Die Option PlotPoints -> n bestimmt die Anzahl der Pfeile pro Koordinatenrichtung (default: 15 Pfeile in 2D, 7 Pfeile in 3D). Bei PlotVectorField3D[] werden mit VectorHeads -> True die Pfeile mit Spitzen versehen (default: False). Daneben gibt es in den beiden Paketen noch Kommandos zum Zeichnen von Gradientenfeldern skalarer Funktionen f(x,y) bzw. f(x,y,z).

PlotGradientField[ f, {x, xmin, xmax}, {y, ymin, ymax} ] PlotGradientField3D[ f, {x, xmin, xmax}, {y, ymin, ymax}, {z, zmin, zmax} ]

In[1]:= Needs["Graphics`PlotField`"]; In[2]:= PlotVectorField[ {Sin[x y], Cos[x y]}, {x, 0, Pi}, {y, 0, Pi}, PlotPoints -> 20 ];

In[3]:= Needs["Graphics`PlotField3D`"]; In[4]:= PlotVectorField3D[ {x, y, z}, {x, -1, 1}, {y, 0, 2}, {z, 0, 2}, PlotPoints -> 5, VectorHeads -> True ];

9.4.4   Animation von Graphiken

Das Prinzip von Animationen mit Mathematica besteht darin, daß zuerst alle Bilder einer bewegten Graphik vollständig berechnet und danach in rascher Abfolge angezeigt werden, sodaß der Eindruck einer Bewegung ensteht. Die Einzelgraphiken können z.B. mit dem Table[]-Kommando zu einer Liste von Graphikobjekten zusammengefaßt werden. Das Paket Graphics`Animation` enthält verschiedene Kommandos, um solche Listen als bewegte Graphiken darzustellen.

ShowAnimation[ {g1, g2, g3, ¼ } ]        animiert die Graphikobjekte gi

In[1]:= Needs["Graphics`Animation`"]; In[2]:= tbl = Table[ Plot[ Sin[x - n], {x, 0, 2Pi}, Frame -> True, FrameTicks -> None, Ticks -> False, PlotPoints -> 50, PlotRange -> {{0, 2Pi}, {-1, 1}}, DisplayFunction -> Identity ], {n, 0, 2Pi - Pi/5, Pi/5} ]; In[3]:= ShowAnimation[tbl];

9.4.5   Export von Graphiken

Zum Export einer Mathematica-Graphik in eine Datei speichert man die Graphik zuerst in einer Variablen und übergibt diese Variable dann als zweiten Parameter an das Display[]- bzw. an das Export[]-Kommando:

Display[ "file ", graphics , "format" ]

Graphikformate (Auswahl, siehe auch Export[]): "EPS"        Encapsulated PostScript "PDF"        Adobe Acrobat portable document format "GIF"        komprimiertes Bitmap-Format (max. 256 Farben) "TIFF"        Bitmap-Format, keine Komprimierung Die Option ImageSize -> {n,m} liefert bei Bitmap-Formaten Bilder mit n×m Pixel.

Die Graphik wird in der Variablen g gespeichert und danach in eine Datei mit dem Namen g.eps im Format Encapsulated PostScript exportiert.

In[1]:= g = Plot[Sin[x], {x, 0, 2Pi}]; In[2]:= Display["g.eps", g, "EPS"];

10   Differentiation

D[f, x]        partielle Ableitung von f nach x, [(¶)/(¶x)]f D[f, {x, n}]        n-te partielle Ableitung von f nach x, [(¶n)/(¶xn)]f D[f, x1, x2, ¼ ]        höhere partielle Ableitungen [(¶)/(¶x1)][(¶)/(¶x2)]¼f D[f, {x1, n1}, {x2, n2}, ¼ ]     [(¶n1)/(¶x1n1)] [(¶n2)/(¶x2n2)] ¼f

Der erste Parameter von D[] ist der abzuleitende Ausdruck, der zweite die Variable, nach der differenziert werden soll. Bei Ableitungen höherer Ordnung muß der zweite Parameter von D[] als Liste {x, n} angegeben werden.

In[1]:= D[x^3 + x^2 + x, x] 2 Out[1]= 1 + 2 x + 3 x In[2]:= D[x^3 + x^2 + x, {x, 2}] Out[2]= 2 + 6 x

Mathematica kennt die Ableitungsfunktionen von allen elementaren Funktionen.

In[3]:= D[ ArcTan[x], x ] 1 Out[3]= ------ 2 1 + x

Zwei Syntaxvarianten zur Bildung der ersten Ableitung von f nach x. Dabei ist f'[x] eine Kurzschreibweise für D[f[x], x] bei Funktionen mit einer Variablen. Intern wird f'[x] durch Derivative[1][f][x] dargestellt. Analog wird auch f''[x] intern als Derivative[2][f][x] dargestellt.

In[4]:= f[x_] := Sin[a x] In[5]:= D[ f[x], x ] Out[5]= a Cos[a x] In[6]:= f'[x] Out[6]= a Cos[a x] In[7]:= Derivative[1][f][x] Out[7]= a Cos[a x]

Der Wert der Ableitungsfunktion von f an der Stelle 0.

In[8]:= {f'[0], Derivative[1][f][0]} Out[8]= {a, a}

f'[x]        erste Ableitung von f nach x, wenn f = f(x) f''[x]        zweite Ableitung von f nach x, wenn f = f(x) Derivative[n1, n2, ¼ ][f][x1, x2, ¼ ]        [(¶n1)/(¶x1n1)] [(¶n2)/(¶x2n2)] ¼f

Bei der Berechnung der partiellen Ableitung mit D[] werden alle Symbole außer den Ableitungsvariablen als Konstante behandelt.

In[9]:= D[ x^n, x ] -1 + n Out[9]= n x In[10]:= D[ x^2 + y^2, x ] Out[10]= 2 x

Hängt y von x ab, so muß y explizit als Funktion von x in der Form y[x] formuliert werden.

In[11]:= D[ x^2 + y[x]^2, x ] Out[11]= 2 x + 2 y[x] y'[x]

Wenn Mathematica keine Informationen über die abzuleitenden Funktionen hat, wird das Ergebnis in allgemeiner Form dargestellt.

In[12]:= Clear[f] In[13]:= D[ f[x]g[x], x ] Out[13]= g[x] f'[x] + f[x] g'[x] In[14]:= D[ f[g[x]], x ] Out[14]= f'[g[x]] g'[x]

11   Integration

11.1   Symbolische Integration