Direkt zum InhaltDirekt zur SucheDirekt zur Navigation
▼ Zielgruppen ▼

Humboldt-Universität zu Berlin - Mathematisch-Naturwissen­schaft­liche Fakultät - Institut für Physik

Einführung in Mathematica

 

Aufruf, Hilfe

Normalerweise ruft man Mathematica mit seiner graphischen Oberfläche auf, entweder über die KDE-Leiste oder im Terminal-Fenster als

      prompt> mathematica

Befehle werden in das Kommandofenster ("Notebook") eingegeben, das Hilfesystem erreicht man über Help .
Wenn es beim Schreiben im Fenster Probleme mit <Backspace> gibt, sollte man <NumLock> ausschalten.
Man beendet das Programm über den Menüpunkt File -> Quit.

Es gibt auch noch den einfachen Textmodus von Mathematica, aufzurufen als

      prompt> math

Es erscheint ein nummeriertes Prompt der Form

      In[n]:=

und wartet auf Input. Hilfe zum Begriff Sos bekommt man hier mit ?Sos , man verlässt Mathematica mit Quit .

Notation

Namen bestehen aus Buchstaben, Ziffern (nicht am Anfang) und $ . Groß- und Kleinbuchstaben werden unterschieden.

Die in Mathematica vordefinierten Größen und Funktionen haben große Anfangsbuchstaben.
Einige Konstanten:

      I  Infinity  Degree (= Pi/180) ...
      Pi  E  EulerGamma  ...

Elementare Funktionen sind u.a.

      Sqrt Exp Log                        (NICHT Ln !)
      Sin Cos Tan Cot Sec Csc ArcSin
      Sinh ..                 ArcSinh ..

Rechenzeichen: + - * / ^ !

Gebrauch der Klammersymbole:
( ) in arithmetischen Ausdrücken,
[ ] für Argumente von Funktionen,
{ } für Listen,
[[ ]] für Indizes.

Zeichenketten werden eingegeben wie "hallo".

Auswertung

Um Ausdrücke auszuwerten, schließt man sie mit <shift><enter> ab. Das Ergebnis wird gleich angezeigt, ein ";" am Ende des Befehls verhindert das.

Das spezielle Symbol % bezeichnet das zuletzt erhaltene Resultat.

Ausdrücke aus Symbolen und ganzen Zahlen werden nur (mathematisch exakt) vereinfacht. Wenn "Komma"zahlen auftreten, wird numerisch ausgewertet.
Einige Beispiele - links die Aufrufe (mit <shift><enter> abzuschließen), rechts ggf. die Auswertung:

      1 + 2                   3
      5/2
      5./2                    2.5
      6/2                     3
      2*abc + 5*abc           7 abc       (abc ist kein Produkt!)
      
      Sqrt[z]
      Sqrt[2]
      Sqrt[2.]                1.4142
      Sqrt[16]                4

      Sin[Pi/2]               1

Mit den Befehlen

      N[expr]
      N[expr, digits]

erzwingt man eine numerische Auswertung, ggf. auch mit Vorgabe der Genauigkeit.

Zuweisung

Durch Eingabe von

      var = expr

wird der Ausdruck expr ausgewertet und das Resultat unter dem Namen var gespeichert. Eine etwaige vorherige Belegung von var wird dabei überschrieben. Nicht belegte Namen stehen für sich selbst und werden wie mathematische Symbole behandelt.

Beispiele (links die Befehle, rechts die Resultate, z.T. in TeX-Notation):

      a = 2                   2
      w = Sqrt[z]             \sqrt{z}
      w^4 + a^2 + 3           7 + z^2

      r = Exp[2*x]            e^{2x}
      r^4                     e^{8x}

Man kann auch mehrere Zuweisungen in einem Befehl vornehmen:

      var1 = expr1; var2 = expr2; ...

Belegungen löscht man mit

      Clear[var1, var2, ..]
      Clear["*"]

Umformungen

Ausmultiplizieren und Faktorisieren:

      Expand[expr]
            Expand[(a + b)*(a - c)]             a^2 + a b - a c - b c

      Factor[expr]
            Factor[a^2 + a*b - a*c - b*c]       (a + b) (a - c)

Vereinfachungen:

      Simplify[expr]
            z = (a^2 - b^2)/(a - b)    (a^2 - b^2)/(a - b)
            Simplify[z]                a + b

            u = a^5 - b^5              a^5 - b^5
            v = a - b                  a - b
            Simplify[u/v]              (a^5 - b^5)/(a - b)
            Factor[u]/v                a^4 + a^3 b + a^2 b^2 + a b^3 + b^4 

Wie man sieht, braucht das Programm manchmal etwas Nachhilfe.

Trigonometrische Relationen sind besonders anspruchsvoll:

      Simplify[expr]                benutzt sin(x)^2 + cos(x)^2 = 1
      TrigExpand[expr]              Additionstheoreme etc
      TrigReduce[expr]              Produkte -> Summen von Funktionen
      TrigFactor[expr]              Faktorisierung
Beispiele:
      Simplify[1 - 1/Cos[x]^2]
            -Tan[x]^2
      TrigExpand[Sin[x+2*y]]
            Cos[y]^2*Sin[x] + 2*Cos[x]*Cos[y]*Sin[y] - Sin[x]*Sin[y]^2
      TrigReduce[%]
            Sin[x + 2 y]
      TrigFactor[Sin[x] + Cos[y]]
            2 * Sin[Pi/4 + x/2 - y/2] * Sin[Pi/4 + x/2 + y/2]

Umformungen, bei denen die Eigenschaften spezieller Funktionen eine Rolle spielen, bekommt man mit

      FullSimplify[expr]

Substitutionen

Kommt in einem Ausdruck ein Symbol vor, das seinerseits belegt ist, dann wird automatisch substituiert.
Beispiel:

      x = 2
      y = a^2
      Sin[x + y]
            Sin[2 + a^2]

x und y sind bis auf weiteres belegt wie angegeben.
Will man Variablen nur vorübergehend setzen, um zu substituieren, dann kann man das als Liste von Zuweisungen schreiben und damit aufrufen:

      With[{var1 = expr1, var2 = expr2, ..}, expr]

Beispiel:

      With[{x = 2, y = a^2}, Sin[x + y]]
            Sin[2 + a^2]

Hier bleiben x und y unverändert, die Zuweisung gilt nur innerhalb des With[..].

Am Ausdruck im zweiten Argument von With[{..}, expr] werden normalerweise nur die im ersten Argument verlangten Substitutionen vorgenommen. Wenn der Ausdruck zuvor ausgewertet werden soll, muss man das mit Evaluate[..] erzwingen:

      z = a + 1
      With[{a = 1}, z]                    a + 1
      With[{a = 1}, Evaluate[z]]          2 

Summe und Produkt

      Sum[expr, {i, imax}]                      ueber i=1,2,..,imax
      Sum[expr, {i, imin, imax}]                ueber i=imin,imin+1,..,imax
      NSum[expr, {i, imin, imax}]               numerische Summation

      Product[expr, {i, imax}]                  ueber i=1,2,..,imax
      Product[expr, {i, imin, imax}]            ueber i=imin,imin+1,..,imax
      NProduct[expr, {i, imin, imax}]           numerisches Produkt

Beispiele:

      Sum[x^k, {k, n}]                          (x (-1 + x^n))/(-1 + x)

      Sum[(-1)^n/(n + 1), {n, 0, Infinity}]     Log[2]

Reihenentwicklung

      Series[expr, {x, x0, n}]

entwickelt expr um x=x0 bis zur Ordnung n, z.B.

      Series[Tan[t]/t, {t, 0, 4}]         1 + (1/3) t^2 + (2/15) t^4 + O[t]^5

Das Resultat ist allerdings, wie man am Symbol O[t]^5 erkennt, ein Objekt von spezieller Art, mit Normal verwandelt man es in ein gewöhnliches Polynom:

      Normal[%]                           1 + (1/3) t^2 + (2/15) t^4

Den Koeffizienten z.B. von t^2 extrahiert man mit

      Coefficient[%, t, 2]                1/3

Grenzwert

      Limit[expr, x -> x0]
            Limit[Sqrt[1 + x^2]/(1 + x), x -> Infinity]           1

Differentiation

Partielle Ableitungen des Ausdrucks expr:

      D[expr, x]
            D[t^3 + 2*t, t]               2 + 3 t^2                    
            D[Log[u], u]                  1/u
      D[expr, x, y]
      D[expr, {x, n}]

Integration

Unbestimmtes Integral:

      Integrate[expr, x]
            Integrate[1/(1 + z^2), z]           ArcTan[z]           

Bestimmtes Integral (symbolisch und numerisch):

      Integrate[expr, {x, a, b}]
            Integrate[1/x, {x, 1, 2}]           Log[2]
      NIntegrate[expr, {x, a, b}]

Definition eigener Funktionen

Einen Ausdruck expr, der die Variable x enthält, kann man in eine "echte" Funktion f umwandeln, die man, wie die vordefinierten Funktionen, mit beliebigem Argument aufrufen kann:

      f[x_] := expr                 Funktion mit einem Argument
      f[x_, y_] := expr             Funktion zweier Argumente

Beispiel:

      radius[x_, y_] := Sqrt[x^2 + y^2]
      radius[3, 4]

Definition und Eigenschaften von radius kann man anzeigen mit

      Definition[radius]
      Information[radius]

Das funktioniert analog auch für andere Mathematica-Objekte, man bekommt ggf. auch einen Link ins Hilfesystem.
Mit Clear[radius] löscht man die Definition wieder.

Listen, Vektoren, Matrizen

Form einer Liste:

      {el1, el2, ..}

Bildung einer Liste mit einem Ausdruck expr und einer Laufvariablen n = n1..n2 bzw. n = 1..n2 :

      Table[expr, {n, n1, n2}]
      Table[expr, {n, n2}]

Wenn man eine Funktion auf eine Liste anwendet, dann wird elementweise ausgewertet, das Resultat ist eine Liste der Funktionswerte.

Listen sind zugleich auch Darstellungen von Vektoren.
Beispiel für Zugriff auf Komponenten:

      vec = Table[n^2, {n, 5}]
      vec[[3]]

Skalarprodukt und Vektorprodukt:

      vec1 . vec2
      Cross[vec1, vec2]

Eine Matrix ist eine Liste von Listen:

      {{a11, a12, a13}, {a21, a22, a23}}

Definition einer (MxN)-Matrix mit Hilfe eines Ausdrucks expr :

      mat = Table[expr, {m, M}, {n, N}]

mit Laufvariablen m=1..M, n=1..N .
Elementweiser Zugriff:

      mat[[i,j]]

Matrixprodukt etc:

      mat1 . mat2
      Inverse[mat]
      Transpose[mat]
      Det[mat]

Gleichungen

Notation:

      expr1 == expr2

Symbolische Lösung von Gleichungen:

      Solve[eqn, var]
      Solve[{eqn1, eqn2}, {var1, var2}]

Solve gibt die Lösungsmenge als eine Liste von Regeln aus. Eine Regel ist eine Vorschrift der Form

      var -> value

und bedeutet, dass var ggf. durch value ersetzt wird. var bleibt aber erstmal unbelegt.
Eine Liste von Regeln hat die Form

      {{x -> a}, {y -> b}, ..}

Dazu ein Beispiel:

      eqn = x^2 == 4                      x^2 == 4
      res = Solve[eqn, x]                 {{x -> -2}, {x -> 2}}
      roots = x /. res                    {-2, 2}
      roots[[1]]                          -2

Das Beispiel zeigt, wie man aus der Liste von Regeln res die Liste der Lösungen roots gewinnt.

Numerische Lösung von Gleichungen:

      NSolve[eqn, var]
      FindRoot[eqn, {x, a}]

Im letzten Fall startet die Lösungssuche bei x=a.

Differentialgleichungen

      DSolve[eqn, y, x]

löst eine Differentialgleichung eqn für y(x). Darin sind die Funktion und ihre Ableitungen in der Form y[x], y'[x], y''[x], .. anzugeben.
Beispiele:

      sol = DSolve[y''[x] == a*y[x], y, x]
      sol = DSolve[{y'[x] == y[x], y[0] == 2}, y, x]

Im ersten Fall erscheint die allgemeine Lösung (mit zwei Integrationskonstanten C[1] und C[2]), im zweiten ist sie gleich an eine Anfangsbedingung angepasst.
Die Lösung sol erscheint als eine Regel der Form

      {{y -> Function[{x}, ...]}}

Man kann sie für Werte x auswerten oder in eine "echte" Funktion f[x] umwandeln:

      y[x] /. sol
      f[x_] := y[x] /. sol

Grafik

2D-Plot des Ausdrucks expr im x-Intervall [x1, x2]:

      Plot[expr, {x, x1, x2}]

3D-Plot einer Funktion von zwei Variablen:

      Plot3D[f[x,y], {x, x1, x2}, {y, y1, y2}]

2D-Plot einer Kurve in Parameter-Darstellung:

      ParametricPlot[{fx[t], fy[t]}, {t, t1, t2}]

2D-Plot von Punkten und Polygon mit Hilfe von Listen:

      ListPlot[{{x1, y1}, {x2, y2}, ..}]
      ListPlot[{{x1, y1}, {x2, y2}, ..}, PlotJoined -> True]

Die Grafik wird in der Arbeitsfläche dargestellt. Wenn das nicht funktioniert, muss man womöglich eine Einstellung reparieren:

      $DisplayFunction = Identity

So exportiert man eine Grafik in eine Datei:

      graph = Plot..[..]
      Export["filename", graph]

Das Grafikformat wird durch die Datei-Erweiterung (eps, pdf, jpg, png, ..) bestimmt. Bei EPS verhindert man eine Drehung des Bildes mit

      Export["xyz.eps", graph, ImageTopOrientation -> Top]

Dateien lesen und schreiben

Liste/Matrix mat aus Datei einlesen bzw. in Datei schreiben:

      mat = Import["dateiname", "Table"]
      Export["dateiname", mat, "Table"]

Aktuelles Verzeichnis anzeigen bzw. wechseln:

      Directory[]
      SetDirectory["verz"]

B. Bunk, 01.03.2013