Einige Berechnungsbeispiele mit  Mathematica

Numerische Rechnungen

Hier ist der Wert von π  auf zweihundert Dezimalstellen genau.

N[Pi, 200]

Mathematica  kennt eine große Anzahl mathematischer Funktionen — die meisten davon können Sie in Formelsammlungen mit Tabellen elementarer und spezieller Funktionen finden.

BesselJ[5, 34.6]

Log[4.5 + 2I]

Zeta[1/2 + 14.3 I]

Mathematica  kann viele verschiedene Operationen mit ganzen Zahlen (Integer) durchführen.  FactorInteger gibt die Primfaktoren einer ganzen Zahl.

FactorInteger[70612139395722186]

Die Mathematica-Funktion FindRoot sucht nach nur einer numerischen Lösungen einer Gleichung, wobei an einem vorgegebenen Punkt mit der Suche begonnen wird.

FindRoot[{Sin[x] == x - y, Cos[y] == x + y}, {x, 1}, {y, 
        0}]

Numerische Integration

NIntegrate[((x^2)/(Cos[x + y + 1] + 5)), {x, 0, 5}, {y, 0, 5}, 
      Method -> MonteCarlo]

NIntegrate[((x^2)/(Cos[x + y + 1] + 5)), {x, 0, 5}, {y, 0, 5}, 
      Method -> QuasiMonteCarlo, MaxPoints -> 5000]

Approximation und Interpolation

Polynomiale Approximation

Werte = {{1, 0}, {2, 6}, {3, 14}, {4, 
            24}};
eqfit = Fit[Werte, {1, x, (x^2)}, x]

Nichtlineare Approximation

<<  Statistics`NonlinearFit`

data  = {{0, 0.0195}, {0.3, 0.61}, {1. , 
            1.34}, {1.5, 1.74}, {2. , 2}, {2.29, 1.9}};

    pl1 = ListPlot[data, PlotStyle -> PointSize[0.02]]

\(eq = 
      NonlinearFit[
        data, 
\((a - b*Exp[\(-c\)*x] + 
            d*Exp[\(-e\)*\((f - x)\)^2])\), 
{x}, \ {a, b, c, d, e, 
          f}]\)

pl2 = Plot[eq, {x, 0, 2.4}]

Show[pl1, pl2, PlotLabel -> Nichtlinearer Ausgleich, 
      GridLines -> Automatic, Frame -> True]

FindFit

data  =  
        Table[ {Cos[t]  +  5,  Sin[t]  +  15,  0. } + 
            Random[Real, {- .05, 0.05}],  {t,  0. ,  2  Pi,  
            0.01}];

<< "Graphics`Colors`"

dg  =  
        ListPlot[ Take[ data,  All,  2], Frame -> True,  
          PlotStyle  ->  Red ,  
          AspectRatio -> Automatic];

Clear[R]

s = 
      FindFit[ data,  (((x - x0))^2) + (((y - y0))^2) - (R^2),  {x0,  
          y0,  R},  {x, y} ]

fg = 
        Show[Graphics[{RGBColor[0, 0, 1], 
              Circle[{x0 /. s, y0 /. s}, R /. s]}], 
          DisplayFunction -> Identity];

Show[ {dg,  fg},  AspectRatio  -> Automatic];

Numerische Lösung einer Differentialgleichung

Anfangswertproblem

anfangsb1 = y[0] == 1; 
    anfangsb2 = ((y )^′)[0] == 1;
dgl=y''[x]==x Sin[y[x]];

lsg = 
      NDSolve[{dgl, anfangsb1, anfangsb2}, y[x], {x, -10, 10}]

Plot[Evaluate[y[x] /. lsg], {x, -10, 10}, 
      FrameLabel -> {"x", "y"}, 
      PlotLabel -> "Differentialgleichung", 
      GridLines -> Automatic, Frame -> True]

NDSolve[{y'[t] == -y[t],  y[0] == 1}, 
      y[t], {t, 0, 
        1}, 
Method -> "ExplicitEuler",  
      StartingStepSize -> 1/10]

EvaluationMonitor & StepMonitor bei einem Anfangswertproblem

{yl, tl}  =  
      Reap[ NDSolve[ y''[t] == -y[t]  &&  
            y[0] == 0  &&  y'[0] == 1,  
          y,  {t,  0, 3  π},  
          StepMonitor  :>  Sow[t]] ]

yf  =  y  /.  First[yl]; 
s  =  Map[ {#,  yf[#]} &,  First[ tl ]];

<< Graphics`MultipleListPlot`

g1  =  
        MultipleListPlot[ s,  SymbolShape  ->  Stem ];

{yl, tl}  =  
      Reap[ NIntegrate[ Sin[t], {t,  0,  3  π}, 
          EvaluationMonitor  :>  Sow[t]] ]

MultipleListPlot[ Map[ {#,  Sin[#]} &,  First[ tl ] ],  
        SymbolShape  ->  Stem ];

Numerische Lösung einer partiellen Differentialgleichung

NDSolve[{(((∂^2) y(x, 
                      t))/(∂t ∂t))==(((∂^2) y(x, 
                        t))/(∂x ∂x))+sin(y(x, t)),y(x, 0) == (E^(-(x^2))),Derivative[0, 1][y](x, 0)==0,y(-5, t) == y(5, t)},y,{x, -5, 5},{t, 0, 5}]

\(\(Plot3D[
        Evaluate[y[x, \ t]\  /. \ First[%]], 
\ \ \ {x, \ \(-5\), \ 
          5}, \ {t, \ 0, \ 5}, \ PlotPoints -> 30];\)\)

Symbolische Rechnungen

Eine der wichtigsten Eigenschaften von Mathematica  ist die Fähigkeit mathematische Terme in algebraischer Form zu verarbeiten.

So reagiert Mathematica, wenn Sie einen einfachen algebraischen Ausdruck eintippen.
Man kann diesen Ausdruck ausmultiplizieren bzw. erweitern:

Expand[(((cos^4)(x) + 
                    2 (sin^2)(x) (cos^2)(x) + (sin^4)(x)) ((((x^2) + 
                      2 x + (cos^2)((x^4)) + (sin^2)((x^4))))^4))/((x^8) + 8 (x^7) + 28 (x^6) + 56 (x^5) + 70 (x^4) + 
                56 (x^3) + 28 (x^2) + 8 x + 1)]

Mathematica  gibt eine explizite Formel als Resultat.
Sie können dieses Resultat faktorisieren, um wieder zum Ausgangspunkt zu gelangen.
(Das Prozentzeichen % representiert das letzte Resultat, das Mathematica  berechnet hat.)

Simplify[%]

Factor[(x^99) + (y^99)]

Differential- und Integralrechnung

Man kann Mathematica  auch zur Differential- und Integralrechnung heranziehen. Hier ist ein einfaches Integral.

Integrate[x^n, x]

Und hier ist eine etwas komplizierteres Beispiel.

Integrate[(1/((x^4) - 1)), x]

∫(1/((x^4) - 1)) \[DifferentialD]x

Versuchen wir nun den letzten Ausdruck wieder zu differenzieren.

D[%, x]

Dies ergibt den ursprünglichen Term in einer anderen algebraischen Form. Um zur kompakten Ausgangsform zurückzukommen, benutzen wir den Befehl Simplify.

Simplify[%]

Mathematica  kann auch exakte Lösungen für viele bestimmte Integrale berechnen.

Integrate[
      x (E^x) Sin[x] - (1/2) (E^x) Cos[x], 
      x]

(∫_0^∞) Exp[a x] \[DifferentialD]x

Integrate[Exp[a x], {x, 0, ∞}, 
      Assumptions -> a < 0]

?? Integrate

Viele Integrale besitzen keine Lösung in geschlossener, analytischer Form. Wenn Sie Mathematica  ein solches bestimmtes Integral eingeben, wird es unverändert wieder ausgegeben. Sie können aber immer den Befehl N benutzen, um eine numerische Antwort zu erhalten.

Mathematica  kann auch Differentialgleichungen lösen. Hier ist ein System zweier Differentialgleichungen. Die Lösung, die Sie erhalten, umfaßt zwei unbestimmte Konstanten.

lsg =DSolve[y''[x]==ay'[x]+y[x],y,x]

Viele  Differentialgleichungen kennen  keine explizite, symbolische Lösung. In diesen Fällen können Sie numerische Näherungen der Lösung mit NDSolve bestimmen.  Nachdem die Lösung berechnet worden ist, kann sie graphisch dargestellt werden.

Ranwertprobleme

randbed1 = y[0] == 1;randbed2=y''[0]==2;
randbed3 = y[5] == 0;randbed4=y''[5]==0;

edl4=(10^6) Derivative[4][y][x]==y''[x]+1

lsg = 
      DSolve[{edl4, randbed1, randbed2, randbed3, randbed4}, y[x], 
        x]

\(Plot[
      Evaluate[y[
            x] /. lsg[[1]]], {x, 0, 5}, 
      PlotLabel -> "Lösung des  Randwertproblems 4.Ordnung", GridLines -> Automatic, Frame -> True, 
      FrameLabel -> {"x", "y"}]\)

Differenzengleichungen

Algebraische Differenzengleichung mit Anfangswertproblem

RSolve[ 
      x[k + 1] == x[k] + 2  y[k]  ∧   0  ==  
          x[k]  +  y[k] ∧  x[0] == 1,  {x,  y},  
      k]

Das Lösen von Gleichungen

Dieses Beispiel zeigt Ihnen, wie Mathematica  quadratische Gleichungen löst.

Solve[(x^2) + 2 a x + 1 == 0, x]

Hier ist eine kompliziertere Gleichung.

Solve[(x^5) + 3  x + 1 == 0, x]

Es ist eine Tatsache der Mathematik, daß es keine Möglichkeit gibt eine exakte Formel für die Lösung einer algebraischen Gleichung fünfter Ordnung wie die hier vorliegende zu finden. Mathematica erlaubt das Arbeiten mit algebraischen Wurzelobjekten zur weiteren Berechnung, oder man kann Mathematica  nach einem numerischen Resultat fragen. Sie erhalten dann die Zahlenwerte der fünf komplexen Wurzeln der Gleichung.

N[%]

Reduce[ (x^2) - 2  (y^2) == 1,  {x, y},  Reals]

FindInstance[ (x^2) - 2  (y^2) == 1,  {x, y},  Reals,  
      3]

Matrizen

Sie können auch alle numerischen Standardmatrixoperationen mit Mathematica. ausführen. Nachfolgend ein paar Matrizenoperationen, wobei wir eien 3x3 Matrix  mat1 benutzen.

mat=(({{1, 5, 0}, {2, 10, b}, {0, 4, 1}}));

Eigenvalues[mat]

Det[mat]

Inverse[mat] // MatrixForm

Grenzwert

Limit[(((E^(-x)) + (E^x) - 2)/(x - Log[x + 1])), x -> 0]

Limit[Tan[x], x -> (π/2), Direction -> 1]

Reihenentwicklung

Series[(((E^(-x)) + (E^x) - 2)/(x - Log[x + 1])), {x, 0, 5}]

Normal[%]

Series[Sin[x y], {x, 0, 6}, {y, 0, 6}]

Programmierung

Mathematica ist eine intuitive und flexible Programmiersprache, die moderne Programmierstile unterstützt. Ein paar davon stelle ich am Beispiel der Fakultäts-Funktion vor. Natürlich besitzt Mathematica die Fakultät.

10!

Prüfen ob  "fac" in irgendeiner Form bereits existiert.

?fac*

Prozedural (Fortran/Basic) Stil

facProcedural[n_] :=
Block[ { i, s = 1},
	Do[s = s*i, {i, 1, n}];
	s
]

facProcedural[10]

Ein weiteres Beispiel

a  =  b;
Do[Print[a  *=  a  +  i],  {i,  5}]

Rekursiv (C) Stil

facRecursive[n_] := If[n == 0, 1, 
			n facRecursive[n-1]]

facRecursive[10]

Listenbasiert (APL, LISP) Stil

facAPL[n_] := Times @@ Range[n]

Mathematica berechnet hier zuerst den Bereich von n und wendet dann die Operation "Times" - Multiplikation - auf jedes Element der Liste an.

facAPL[10]

Ein weiteres Beispiel

Table[ i^j,  {i,  4},  {j,  i}]

%  //  Flatten

Partition[ %,  2]

%  //  Transpose

Regelbasiert

facRule[n_] := n facRule[n-1]

facRule[0] = 1

facRule[10]

Noch ein Beipiel, der Logaithmus

nlog[a b c d^2]

Anfangs weiß Mathematica  nichts über unsere neue Funktion, so daß es keine Unformungen an Ausdrücken mit nlog vornimmt.

nlog[x_ y_] := nlog[x] +nlog[y]

Diese Zeile unterrichtet Mathematica , wie der Logrithmus eines Produktes als Summe der Logarithmen der Faktoren geschrieben werden kann.

nlog[a b c d^2]

Nun kann Mathematica  den Ausdruck nlog erweitern.

nlog[x_^n_] := n nlog[x]

Dies definiert die Regel zur Umformung von nlog einer Potenz.

nlog[a b c d^2]

Funktional

newton3[n_]  :=  N[1/2 (n + 3/n)];

a  =  NestList[newton3, 1.5, 10]

newton1[n_] := NestList[N[1/2 (# + 3/#)] &,  1.5, n]

Hier ist eine Funktion,die einen Schritt des Newtonschen Näherungsverfahrens zur Berechnung von(Sqrt[3])ausführt.

ListPlot[ a,  PlotJoined -> True];

NestList[f, ausdr, n] nimmt den „Namen“ f einer Funktion und wendet die Funktion n-mal auf ausdr an. Wie schnell nähert sich Sinuns Funktion an Ihrem Fixpunkt bei Null.

NestList[Sin, 0.1, 30]

RandomWalk[n_]  :=  
        NestList[(# + (-1)^Random[Integer]) &,  0,  
          n];

ListPlot[ RandomWalk[200],  PlotJoined -> True,  
        PlotRange -> All];

Stringbasiert

t  =  "1.2345E-6";

StringReplace[ t,  {"E" -> " 10^"}]

%  //  ToExpression

Graphik

Hier ist ein einfacher Mathematica  Graph.

Plot[Sin[x], {x, 0, 2Pi}]

Es gibt viele Optionen für Graphen, die Sie spezifizieren können.  Mit dem Befehl  Show können Sie den vorherigen Graphen mit geänderten Optionen neu zeichnen.

Show[% , Frame -> True, 
            PlotLabel  -> "Die Sinus-Funktion"]

Plot[ Sin[x], {x,  0,  2  π},
	PlotLabel -> "Mathematica V5 μ ζ θ"];

Nun einige 3-dimensionale Graphiken.

Plot3D[Sin[x] Sin[3 y] , {x, -2, 2}, {y,-2, 2}]

Hier ist ein Höhenliniendiagramm der selben Funktion.

Show[ ContourGraphics[ % ], ContourShading -> False,
                            ContourSmoothing -> True]

Der folgende Befehl erzeugt eine 3-dimensionale parametrisierte Fläche.

ParametricPlot3D[ {u Sin[t], u Cos[t], t/3},
              {t, 0, 12}, {u, -1, 1}, Ticks -> None]

Mathematica  erzeugt alle Graphiken in PostScript, damit die Bilder vergrößert und verkleinert werden können, und damit die auf verschiedenen Druckertypen zur Verfügung stehende Auflösung ausgenutzt werden kann.

Visualisierung

<< RealTime3D`

Show[
        dxfgraph = 
          Import["C:\\Dokumente und Einstellungen\\Administrator\\Eigene \
Dateien\\Post\\Mma\\Demo\\4.1Talk\\hughes_500.dxf"],  
        Boxed  ->  False];

Beispiel Datenanalyse eines Kernspintumographie: 3DKopf

Bewegte Graphik (Animation)

In einem Notebook kann man Sequenzen von Graphikzellen als Bilder eines Filmes verwenden..

Dieses Notebook enthält eine Mathematica  Animation.

Um die Animation laufen zu lassen:

verschieben Sie den Fensterauschnitt, so daß die erste Graphikzelle vollständig sichtbar wird. (Der Film wird in dieser Zelle abgespielt.)

klicken Sie diese Graphikzelle zweimal an, um den Film zu starten.  
Ein weiterer Klick innerhalb des Notebook-Fensters stoppt die Animation.

Do[Plot3D[Sin[x y], {x, -n, n}, {y, -n, n},Mesh->False], 
   {n, 1, 3, 3/23}];

Technische Dokumentation

Here is some ordinary text. It can be in any font, face, size, color, etc.  You can have special characters such as 🐺 as well as formulas such as ∫(1/((x^5) - 
                1)) dx embedded in text.

Like other objects in Mathematica, the cells in a notebook, and in fact the whole notebook itself, are all ultimately represented as Mathematica expressions. With the standard notebook front end, you can use the command Show Expression to see the text of the Mathematica expression that corresponds to any particular cell.

Historical Daily Data for Microsoft (MSFT)

High-Low-Open-Close

Summary Statistics

Ton

Mathematica  kann nicht nur Graphiken sondern auch Töne produzieren. Genau so wie Sie eine Funktion mittels Plot als Graphik auftragen, können Sie eine Funktion mittels Play akustisch wiedergeben.

Um einen Ton abzuspielen, müssen Sie das kleine Lautsprecher-Symbol am oberen Ende der Tonzellenklammer (rechts) zweimal anklicken.

Diese Tonzelle spielt  für eine Sekunde einen reinen Ton mit einer Frequenz von 440 Hertz.

Play[Sin[2Pi 440t], {t, 0, 1}]

Diese Tonzelle spielt einen komplexeren Ton.

Play[Sin[1000 t ( 1 + 0.1 Sin[100 t] Sin[20 t])], 
		{t, 0, 2}];