Erstes mathematisches Auswerten (Shift + Enter)

ausgewertet wird nicht mit Enter sondern Shift und Enter (Umschalttaste)

Addition, Subtraktion, Multiplikation, Division, Klammern

5+5

3-5

5*3

15/3

5+5-2+5*10/2-(5*5)

Exponenzieren, Potenzieren

12^2

2^2^2

x^2

2^x

Exp[2]

Wurzeln ziehen (Sqrt, Surd, Inverses Exponenzieren, (in TraditionalForm))

Quadratwurzel:

Sqrt[144]

3 - te Wurzel aus 27:

Surd[27,3]

Wurzelziehen über inverses Exponenzieren :

27^(1/3)

Mathematica macht einen Unterschied zwischen Wurzeln und inversen Exponenten
(mit Absicht, die gelten nämlich nichtmehr so einfach im komplexen)
TraditionalForm bringt den Ausdruck in mathematische Form
(man achte auf das hintere rechte Ende der Wurzel) :

Sqrt[x]//TraditionalForm

Surd[x,2]//TraditionalForm

x^(1/2)//TraditionalForm

Logarithmieren

Logarithmus zur Basis e :

Log[1]

Log[2]

Log[Exp[3]]

Logarithmus zur Basis 5 :

Log[5,25]

ans

Das Ergebnis des letzten Outputs kann mit % angegeben werden:

5*5

%+5

Mit %N (N eine Nummer) könnt ihr auf einen bestimmten Output verweisen. Das kann ich hier leider nicht zeigen, da die Inputs nicht mit abgespeichert werden.

Konstanten (Pi, e, i)

Man achte auf groß und Kleinschreibung

Pi+E+I

Mathematica kennt auch viele andere math. Konstanten (ignoriert erstmal das “//N” dahinter)

GoldenRatio//N
Degree//N (*Der Umrechnungsfaktor von deg->rad*)
EulerGamma//N

Viele physikalische und chemische Konstanten können (leider recht kompliziert) aus Befehlen geholt werden.

UnitConvert[Quantity[1,"PlanckConstant"],"SIBase"]

QuantityMagnitude[UnitConvert[Quantity[1,"PlanckConstant"],"SIBase"]] (*ohne Einheit*)

QuantityVariablePhysicalQuantity

UnitConvert[Quantity[1,"SpeedOfLight"],"SIBase"]

UnitConvert[Quantity[1,"AvogadroConstant"],"SIBase"]

Numerische auswertung N[]

N[Pi]

N[Pi,20]

Sqrt[2]

N[Sqrt[2]]

Alternativ kann auch ein bereits numerischer Wert zu einem exakten Wert hinzugerechnet werden, wodurch Mathematica automatisch in den numerischen Modus wechselt.

1.0*Sqrt[2]

Wir können auch den “Thought-After”-Operator anwenden. Anstatt das Argument von N komplett zu umklammern, kann man auch ein doppelten Slash mit dem Befehl dahinter nachstellen.
N[arg] == arg//N
Das kann man immer nur dann machen, wenn die Funktion auf die der Operator wirkt auch tatsächlich nur ein Parameter bekommen kann.

Sqrt[2]//N

InputCells

InputForm

5+5+Sin[2*Pi]

FreeFormInput ( = )

Wolfram Alpha Anfrage ( == )

Sonderzeichen (Palettes)

mit escape eingeben

α

∑

Oben im Menü im Unterpunkt Palettes

(∫_lower^upper)expr\[DifferentialD]var

Output unterdrücken

Ausdrücke, die auf ein Semikolon enden, werden nicht ausgegeben.

5+5+1;
3-1
2+2;

Sonstige Formatierungen

siehe die Formatierung dieses Notebooks hier (Kapitel, Unterpunkte, usw.)
(Zelle selektieren, Format->Style->...)
Beispielsweise, DisplayFormulaNumbered:

(∑_(n=1)^∞)(1/(n^2))=((π^2)/6)

Dokumentation

Help->Wolfram Documentation

(oder : Maus über Befehl und auf das i klicken [Informationssymbol])

Variablen

Definition

a=5

a

a+5

a=10

a

a=a+5

a

Einsatz in Gleichungen

V=h*Pi*(d/2)^2

V

h=10;
d=6;

V

N[V]

Listen

Listen werden mit geschweiften klammern geschrieben. Die meisten operationen laufen elementweise (NICHT ALLE).

{1,2,5,Pi,-3,2.5,1/2,x}

{1,2,5,π,-3,2.5`,(1/2),x}+5

Listen können natürlich auch ohne weiteres in Variablen gespeichert werden.

liste={-2,0,2,4,8,16,32,64,42,1.1,2/3}

liste

liste*5

liste+liste

Löschen

Wenn eine Variable nichtmehr gebraucht wird aber stört, kann man sie "löschen" :

a=5;

a

Clear[a]

a

Allerdings sollten Argumente im Clear mit Anführungszeichen geschrieben werden. (Warum? Das sprengt den Ramen dieser Einführung. Machts einfach.)

Clear["a"]

Unterschied : Set ( = ) und SetDelayed ( := )

a=RandomReal[];
b:=RandomReal[];

Zur Variablenzuweisung kann auch der SetDelayed Operator (:=) benutzt werden (bzw. die respektiven Befehle). Der Unterschied besteht in der Auswertung des rechten Arguments. Bei der normalen Zuweisung mit = wird das rechte Argument bei der Zuweisung EINMAL ausgewertet und dann nurnoch bei Bedarf.
Beim SetDelayed Operator, wird die rechte Seite bei jeder Abfrage neu ausgewertet. Das führt dazu, dass die Variable b beim aufrufen immer wieder eine neue Zufallszahl auswertet aber die Variable a immer den gleichen Wert trägt, da dieser bei der Zuweisung fest ausgewertet wurde. In der “Freien Wildbahn” ist natürlich der normale Set Operator häufiger anzutreffen.

a
a
a
a

b
b
b
b

Erster (richtiger) Befehl : Simplify[___]

Syntax

Simplify nimmt in seiner einfachsten Form nur einen Parameter entgegen. Nämlich die Gleichung/Formel/Term, die/der vereinfacht werden soll.

Simplify[n^2+2n+1]

Simplify kommt auch mit Gleichungen klar. Dabei ist wichtig: eine Gleichung wird mit ZWEI GLEICH-ZEICHEN angegeben.
Warum? Weil das Gleich-Zeichen “=” ist schon für Variablen-Zuweisen vergeben!

Simplify[m^2+m+1==m]

Sollte Simplify “True” ausgeben, dann konnte die Gleichung zu einer wahren Aussage umgeformt werden.

Simplify[n/(n+1)+1/((n+1)*(n+2))==(n+1)/(n+2)]

Analog gilt natürlich auch, das bei “False” zu einer falschen Aussage umgeformt werden konnte.

Simplify[n^2+2n+2==(n+1)^2]

Simplify kann auch Ungleichungen bearbeiten.

Simplify[5n>4n]

Rechenregeln

Wir betrachten nun einen (scheinbar) einfachen Fall für Mathematica eine Gleichung zu vereinfachen. Die Quadratwurzel aus x im Quadrat. Es sollte x herauskommen richtig?

Simplify[Sqrt[x^2]]

Huch, was ist den jetzt passiert?
Die Antwort ist, dass unsere Vereinfachung nur für positive Reelle Zahlen gilt. Also sagen wir Mathematica erstmal, dass sie reell ist.

Simplify[Sqrt[x^2],x∈Reals]

Der Befehl Abs[] ist übrigens der Betrag. Das ist tatsächlich das, was für alle reelle Zahlen gilt. Das ∈-Zeichen haben wir mit Escape eingegeben. Es gibt aber auch ein Befehl dafür.

Simplify[Sqrt[x^2],Element[x,Reals]]

Dann lasst uns jetzt mal sagen, dass x größer 0 ist.

Simplify[Sqrt[x^2],x>0]

Das ging jetzt schneller als wir dachten. Wieso konnte es hier schon zu x vereinfacht werden? Die Antwort ist leicht. Mathematica ist sich dem Fakt bewusst, dass kein Ordnungstheorem in den komplexen Zahlen existiert. Es konnte also automatisch ohne unser Zutun annehmen, dass x maximal reell ist. Aber zur Vollständigkeit halber geben wir beide Fakten an. Bei mehreren Einschränkungen, werden diese mit einem doppelten &-Zeichen getrennt oder als Liste angegeben.

Simplify[Sqrt[x^2],x∈Reals&&x>0]

Simplify[Sqrt[x^2]+Sqrt[y^2],{y∈Reals,x>0}]

FullSimplify

Es kann manchmal sein, dass eure Formeln ungewöhnliche Funktionen enthalten. Das normale Simplify kann diese nicht bearbeiten. Dafür wurde eine zweite Funktion eingeführt. Das FullSimplify.
Die Trennung hat performancetechnische Gründe aber das hat uns nicht zu interessieren. Im Generellen gilt: FullSimplify kann alles was Simplify kann plus die Möglichkeit auch mit ungewöhnlichen Funktionen arbeiten zu können. Normalerweise reicht ein einfaches Simplify. Ihr werdet es wissen, wenn ihr FullSimplify einsetzen müsst.

FullSimplify[n*Gamma[n]]

FullSimplify kann auch kompliziertere trigonometrische Ausdrücke (mit hilfe von Euleridentitäten usw.) auswerten.

FullSimplify[Exp[I*x]+Exp[-I*x]]

Die Fähigkeiten von FullSimplify gehen sogar so weit, dass es einfache Theoreme beweisen kann.

FullSimplify[f[f[u,f[v,w]],u]==f[u,f[f[v,w],u]],ForAll[{x,y,z},f[x,f[y,z]]==f[f[x,y],z]]]

Ein weiteres nettes gimmik: FullSimplify ist sich dem großen Fermat’schen Theorem bewusst:

FullSimplify[x^n+y^n==z^n,Element[x|y|z|n,Integers]&&n>2&&x y z≠0]

Differenzieren D[___,___] und Dt[___,___]

Partielles differential D[___, ___]

Die Funktion nimmt in der einfachsten Form zwei Parameter entgegen. Eure Funktion und die Variable nach der abgeleitet werden soll.

D[5x^2+3x+2,x]

Generell gilt, kann Mathematica die Ableitung nicht bilden, könnt ihr es vermutlich eher nicht...

D[Cos[Sin[x^x]^2+ArcTan[x*Cos[x]]]^2-Log[Sin[x]],x]

Mehrfache partielle Ableitung

Bei Mehrfachableitungen ist der zweite Parameter dann eine Liste aus Variable und Grad der Ableitung.

D[5x^2+3x+2,{x,2}]

Auch nach mehren Variablen kann Mathematica mehrfach ableiten genauso, wie es mit Vektorfeldern umgehen kann.

D[x*y*z,{{x,y,z}}]

D[x*y*z^2,{{x,y,z},2}]//MatrixForm

D[{x*Sin[y],-y^x+z,z*y},{{x,y,z}}]//MatrixForm

Totale Ableitung

Während D[] nur partielle Ableitung berechnet, kann Dt[] totale Ableitungen berechnen.

Dt[m*v,t]

Dt[f[x,y,z],x]//TraditionalForm

Integrieren Integrate[___, ___]

Unbestimmtes Integral

Auch hier gilt, die einfachste Form besteht aus der Formel und der Integrationsvariable

Integrate[6x^2+10x+2,x]

Hier gilt aber, es gibt keinen eingebauten Weg EINE Integrationsvariable direkt mehfach zu integrieren.

Bestimmtes Integral

Die Integralsgrenzen werden über eine Liste mit der Integrationsvariable bestimmt.

Integrate[2x+1,{x,0,2}]

Ein nett-to-know ist: Mathematica vermeidet bei einigen bestimmten Integralen Polstellen  selbstständig (vorausgesetzt, es konvergiert trotzdem).

Integrate[Sin[x]/x, {x,-∞,∞}]

Das ist aber oft nicht der Fall.

Integrate[Tan[x],{x,0,Pi/2}]

Die Lösung die Mathematica im nächsten Beispiel anbietet ist FALSCH. Es hat beim auswerten einfach die Polstelle bei Pi/2 nicht beachtet/gefunden. Denkt also auch selbst nach bevor ihr Mathematica blind vertraut.

Integrate[Tan[x],{x,0,Pi/2+0.1}]

(für Kenner gilt : gerade dieses Integral lässt sich über eine Option (Cauchy’schen Hauptwert) trotzdem zum lösen überrreden)

Abs[Integrate[Tan[x],{x,0,Pi/2+0.1},PrincipalValue->True]]

Dieses Vorgehen geht auch für andere (eigentlich nicht lösbare) Integrale:

Integrate[1/x, {x, -1, 2}, PrincipalValue->True]

Flächen/Volumen /. .. Integral

Auf Kosten der Mehrfachintegration, bekommen wir aber die mehrdimensionale Integration. Hier das Volumen einer Kugel in Kugelkoordinaten integriert.

V=Integrate[r^2*Sin[θ],{r,0,R},{θ,0,Pi},{ϕ,0,2Pi}]

Solving

Solve

Solve stellt nach Variablen um, lößt Gleichungen und vereinfacht dabei meistens auch noch (das passiert so auf dem Weg dahin ganz nebenbei).

Solve[x^2-2x-3==0,x]

Solve[x^2+2==0]

Solve[a*x^2+a*x+b==4,a]

Manchmal kann es sein, dass euch Mathematica eine Lösung mit einem Befehl mit einem “Root” drinn beschert. Löst das dann einfach mit N[] numerisch auf.

Solve[x^5+x+11==0]

N[Solve[x^5+x+11==0]]

Solve lößt auch Gleichungssysteme.

Solve[{0==4x+y,y==-x+1},{x,y}]

SolveAlways (aka Triviallösung)

SolveAlways ist dafür da euch eine Lösung zu finden für ein (unterbestimmtes) Parameterproblem. Dabei könnt ihr euch sicher sein: wenn es eine Triviallösung gibt, wird SolveAlways diese finden!
Ihr gebt einmal eure Gleichung an, und als zweiten Parameter die Variablen die ihr “festhalten” wollt. Im Prinzip ist es ein Koeffizientenvergleich.

SolveAlways[u*x^2+4v*x+w*3==3,x]

Im nächsten Beispiel meckert er so, da er den natürlichen Logarithmus einsetzen musste. Wie wir alle wissen ist der aber nur für positive Zahlen richtig definiert (bzw. reell und für 0 nicht definiert) und Mathematica schränkt ungern/ungefragt den Definitionsbereich ein. Er findet in diesem Fall aber trotzdem die einzige richtige Lösung.

SolveAlways[Exp[a*x]==Exp[4*x],x]

Reduce (aka Solve hat nichts gefunden...)

Es kommt (leider) öfter vor, dass Solve kein Erfolg hat. Das kann verschiedene Gründe haben. Aber in manchen Fällen hat Reduce mehr Erfolg. Wie der Name schon sagt, ist Reduce aber eigentlich dafür da, eure Gleichung(ssysteme) zu reduzieren aber wenn er sie lösen kann, dann macht er das auch.

Reduce[Sin[x]==Cos[x],x]

Hier kommt eine Aufgabe um Solve und Reduce zu vergleichen. Solve findet (aufgrund von ArcSin) nur eine Lösung, Reduce findet alle (wenn auch nur numerisch).

Solve[Sin[x]==0.5,x]

Reduce[Sin[x]==0.5,x]

Plotting

Plot 2 D

Gleichungsplot

Einfacher Plot

Ein einfacher Plot wird angegeben mit der Funktion und der Liste der Plotvariable und den Plotgrenzen auf der Abszissenachse

Plot[Sin[x],{x,-2,2}]

Multiple Gleichungen

Mehrere Gleichungen lassen sich über eine Liste plotten

Plot[{Sin[x],Cos[x],Tan[x]},{x,-Pi,Pi}]

PlotRange

Im letzten Beispiel sehen wir irgendwie zuviel Ordinatenachse. Durch eine Option (das ist ein Optionaler Parameter mit anderer Form) lässt sich das angezeigt Gebiet sehr genau festlegen.

Plot[{Sin[x],Cos[x],Tan[x]},{x,-Pi,Pi},PlotRange->{{-2,2},{-1.5,1.5}}]

PunktePlot

Einfacher ListPlot

ListPlot[{1,2,4,8,16,32,64}]

Man kann die Punkte auch verbinden über eine Option.

ListPlot[{1,2,4,8,16,32,64},Joined->True]

ListPlot mit Punkten

ListPlots können auch ganze Punkte Plotten

ListPlot[{{0,0},{1,1},{1,2},{2,2},{2,1},{1.5,0.5},{0,0}},Joined->True]

Show

Mit Show[] können verschiedene Grafikelemente (Plots sind welche) miteinander verschmolzen werden.

Show[Plot[Sin[x],{x,0,2Pi}],ListPlot[{{0,0},{1,1},{2,0.5},{3,0.25},{4,0.5},{5,0.75},{6,0.7}}]]

Plot 3 D

Einfacher Gleichungsplot

Plot3D[x^2+Sin[y*4],{x,-2,2},{y,-Pi,Pi}]

ListPlot3D

Der ListPlot3D verbindet die Punkte mit einer Fläche. Das ist eher seltener gewünscht.

ListPlot3D[{{-1,-2,2},{8,-3,9},{-9,-6,6},{-5,5,6},{-2,1,5},{-2,9,0},{3,-3,9},{-1,-6,-7},{-4,7,-4},{-3,-1,-6},{3,9,-4},{8,-3,6},{8,9,-2},{9,8,-6},{-6,6,-6},{-2,1,6},{8,7,-1},{-3,4,-1},{-8,-8,5},{4,9,9}}]

ListPointPlot3D

ListPointPlot3D[{{-1,-2,2},{8,-3,9},{-9,-6,6},{-5,5,6},{-2,1,5},{-2,9,0},{3,-3,9},{-1,-6,-7},{-4,7,-4},{-3,-1,-6},{3,9,-4},{8,-3,6},{8,9,-2},{9,8,-6},{-6,6,-6},{-2,1,6},{8,7,-1},{-3,4,-1},{-8,-8,5},{4,9,9}}]

...

“Pflichtstoff durch. Alles was jetzt kommt ist Extra”

Grenzwerte

Folgen (Limit)

Limit[2+1/n,n->Infinity]

Limit[Sin[n]/n,n->0]

Limit[Sin[n]/n,n->Infinity]

Reihen (Summen)

Sum

Sum[x^n,{n,0,10}]

Sum[n,{n,1,N}]

Sum[1/n^2,{n,1,Infinity}]

SumConvergence

Konvergiert eine Summe wenn ihre untere Grenze fest ist und ihre obere Grenze gegen unendlich geht?

SumConvergence[Log[n]/n,n]

SumConvergence[Log[n]/Exp[n],n]

Okay und gegen was?

Sum[Log[n]/Exp[n],{n,1,Infinity}]

Und numerisch ist das?

N[-Derivative[1,0][PolyLog][0,(1/E)]]

Sonstiges

Listen (Range, Table)

Range erstellt eine austeigende Liste von Zahlenwerten

Range[10]

Range[5,15]

Range[5,15,2]

Der Table Befehl wertet einen Ausdruck mit fortlaufenden Parameter als Liste aus. 
!!! Dieser Befehl ist euer Nummer 1 Werkzeug um eure Daten zu bearbeiten wenn ihr mit Mathematica euer Praktikum rechnet !!!

Table[d,10]

Table[n*d,{n,10}]

list=Table[n^2,{n,5,10}]

Auf das n-te Element einer Liste kann mit dem Part-Operator zugegriffen werden. Dieser hat sein erstes Element bei 1

list[[2]]

Matrizen

Eine Matrix wird mit einer Liste in einer Liste dargestellt. Dabei stellen die inneren Listen die Zeilen da (bei einer n*n-Matrix).

mat={{1,0,0},{0,1,0},{0,0,1}}

MatrixForm[mat]

Die Matrixmultiplikation erfolgt NICHT mit dem *-Operator. Für diesen gelten wieder die Elementweisen Operationen. Der Matrixmultiplikationsoperator ist der Punkt.

mat=mat*2

mat.{a,b,c}

{{1,0,-2},{-1,-1,2},{3,0,2}}.{{1/4,0,1/4},{-1,-1,0},{-3/8,0,1/8}}

Eigene Funktionen definieren

Eine eigene Funktion wird wie eine Variable mit dem SetDelayed-Operator definiert, welche einen Funktionskörper mit Parameter trägt. Diese Parameter müssen (ohne Erklärung) auf einen Unterstrich enden. (ACHTUNG: eigene Variablen innerhalb der Funktion zu definieren ist nicht ohne Umwege möglich. Siehe: Module, Block, With)

function[x_,y_]:=x+y

function[5,3]

Taylorreihe

Es gilt: 1.:Funktion - 2.: Eine Liste mit: (1.: der Variable - 2.: dem Entwicklungspunkt - 3.: die Ordnung der Entwicklung)

Series[Sin[x],{x,0,5}]

Nachbau der Taylorreihenfunktion

T(f(x),x,n,(Subscript[x, 0]))=((∑_(i=0)^n)(1/(i!))×(((∂^i)/(∂(x^i)))f((Subscript[x, 0])))×(((x-(Subscript[x, 0])))^i))+((O[x-(Subscript[x, 0])])^(n+1))

Ohne nähere Erklärung gilt, ein Wert kann eingesetzt werden mit “/.VARIABLE->WERT”:

mySeries[func_,var_,x0_,n_]:=Sum[1/(i!)*(D[func,{var,i}]/.var->x0)*(var-x0)^i,{i,0,n}]+O[var-x0]^(n+1)
mySeries[Sin[x],x,0,5]

Jetzt versuchen wir noch das Punktargument von der Series Funktion nachzuahmen.
Ohne erklärung gilt: Der i-te Wert aus einer Liste kann mit dem Part-Befehl oder Operator entnommen werden: List[[i]]

mySeriesEx[func_,pointArg_List]:=Sum[1/(i!)*(D[func,{pointArg[[1]],i}]/.pointArg[[1]]->pointArg[[2]])*(pointArg[[1]]-pointArg[[2]])^i,{i,0,pointArg[[3]]}]+O[pointArg[[1]]-pointArg[[2]]]^(pointArg[[3]]+1)
mySeriesEx[Sin[x],{x,0,5}]

Wichtiges Fürs Praktikum

Wichtige Befehle

Mean

Ermittlung des Durchschnitts einer Liste

Mean[{5,4,6,6,6,4,5,4,3,5,5,4,5,6,7}]

Length

Bestimmt die Anzahl aller Elemente in einer Liste

Length[{5,4,6,6,6,4,5,4,3,5,5,4,5,6,7}]

Total

Summiert alle Elemente in einer Liste zusammen

Total[{5,4,6,6,6,4,5,4,3,5,5,4,5,6,7}]

StandardDeviation

Berechnet die Standartabweichung der Werte einer Liste

StandardDeviation[{5,4,6,6,6,4,5,4,3,5,5,4,5,6,7}]

N[2 (Sqrt[(2/7)])]

Regressionen

Lineare Regressionen

Für lineare Regression existiert der Befehl LinearModelFit. In der einfachsten Form nimmt er drei Parameter entgegen.
1.: die Daten als Liste nach denen gefittet wird als Punkte {{x1,y1},{x2,y2},{x3,y3},...,{xn,yn}}
2.: eine Liste der linearen Funktionen die mit einem Koeffizienten gefittet werden sollen {x^2,x^3,Exp[x],...}
(Standartweise wird ein konstanter Koeffizient mitgefittet. Das lässt sich mit “IncludeConstantBasis->False” abstellen)
3.: die Fitvariable der Funktionen

Hier ein Beispiel:

LinearModelFit[{{1,0.5},{2,3.5},{3,10.5},{4,21.5},{5,36.5}},{1,x,x^2},x]

Wir sehen, dass das Ergebnis der Regression ein FittedModel-‘Objekt’ ist. Aus diesem lassen sich Informationen ziehen wie Parameterwerte mit Fehlern oder Correlationsmatrizen usw.
Weiteres dazu zwei Unterpunkte weiter!
Jetzt bleibt die Frage, wie wir gewichtet regressieren. Dafür hat LinearModelFit die Option ‘Weights’

LinearModelFit[{{1,0.5},{2,3.5},{3,10.5},{4,21.5},{5,36.5}},{1,x,x^2},x,Weights->{1,1,1,1,1}]

Hat man eine Liste von Fehlern (Subscript[σ, i]) dann werden diese Instrumentell gewichtet mit: (1/(Subscript[σ, i]^2))
(die wahren Werte hier waren 1+x^2 mit einer Zufälligen Abweichung von 0.2 Sigma der Normalverteilung für die y-Werte)

LinearModelFit[{{0,0.761},{0.5,0.921},{1.0,1.976},{1.5,3.157},{2.0,4.954}},{1,x^2},x,Weights->1/{0.24,0.33,0.02,0.9,0.04}^2]

Nichtlineare Regressionen

Für nichtlineare Fits gibt es NonlinearModelFit. Die einfachste Form braucht folgende Parameter:
1.: die Daten (in der selben Form wie beim linearen Fit)
2.: die Gleichung nach der gefittet werden soll
3.: die Regressionkoeffizienten der Gleichung
4.: die Fitvariable der Funktion
(die wahren Werte hier waren 0.5*Exp[2*x] mit einer Zufälligen Abweichung von 0.2 Sigma der Normalverteilung für die y-Werte)

NonlinearModelFit[{{0.0,0.404},{0.5,1.749},{1.0,3.839},{1.5,10.178},{2.0,27.521}},a*Exp[b*x],{a,b},x,Weights->1/{0.1,0.4,0.1,0.1,0.2}^2]

BestFit, ParameterTable, (Adjusted)RSquared, ANOVATable

Um jetzt Daten aus diesem Objekt zu bekommen müssen wir mit einem Keyword darauf zugreifen:

fit=FittedModel[0.5206814625765702` (E^(1.9835607423123018` x))];

BestFit gibt die beste Representation (standartmäßig mit 6-7 signifikanten Stellen) der gefitteten Funktion aus

fit["BestFit"]

Die ParameterTable gibt alle Parameter mit ihren Werten (Estimate), den Unsicherheiten (Standard Error), und zwei Statistischen Werten für Signifikanztests aus.
Für den P-Value gilt nebenbei: größer als 0.005 deutet auf eine schlechte statistische Signifikanz hin.

fit["ParameterTable"]

Der (R^2)-Test kann ebenfalls automatisiert geführt werden. Dabei ist wichtig, dass ihr IMMER den AdjustedRSquared nehmt,da der normale (R^2)-Test ungenau wird für Regressionen mit großer Menge an Daten.

fit["RSquared"]

fit["AdjustedRSquared"]

Zu guter Letzt fehlt noch der (χ^2)-Test. Dieser findet sich in der ANOVATable (ANOVA=Analysis of Variance). Der für die Regression wichtige Wert ((χ^2)/dof) findet sich in der ‘Error’-Zeile und MS-Spalte.
In diesem Beispiel also: ((χ^2)/dof)=0.823518

fit["ANOVATable"]

Zum Abschluss noch ein Wort der Warnung: Anders als LinearModelFit, kann der NonlinearModelFit tatsächlich Gefahr laufen NICHT zu konvergieren. Mathematica zeigt euch das dann mit einer Fehlermeldung an. Sollte euch so etwas passieren, dann liegt es an euch, die Startparameter bereits in der ungefähren Größenordnung richtig selbst zu bestimmen. Das könnt ihr dann dem Fit mitgeben und er wird konvergieren. Ihr könnt die Parameter mit den Startparametern als Listen versehen.
z.B. (a startet hier bei fünf und b bei minus zwei): NonlinearFitModel[daten,f(x),{{a,5},{b,-2}},x]

ErrorBarPlot

Die Fähigkeit per Befehl Errorbalken zu plotten hat Mathematica nur versteckt. Es befindet sich in einem standartmäßig mitgelieferten ‘Package’.
Dieses muss erst mit Needs[] geladen werden.

Needs["ErrorBarPlots`"]

Jetzt kann der Befehl ErrorListPlot angewendet werden. Dabei ist die Syntax recht einfach: anstatt Punkte zu definieren, wird der Punkt jetzt mit dem Befehl ErrorBar in eine Liste eingeschlossen.
Dabei nimmt ErrorBar entweder nur die y-Abweichung auf oder noch zusätzlich die x-Abweichung zuerst. (ErrorBar[dy] oder ErrorBar[dx,dy])

ErrorListPlot[{{{1,1},ErrorBar[0.25]},{{1.3,0.7},ErrorBar[0.07,0.3]},{{1.7,0.5},ErrorBar[0.05,0.4]},{{2,2},ErrorBar[0.10]}}]

Vollständiges Beispiel zur Berechnung eines Messwertes

Es sei eine Messung gegeben:

messwerte={5.2,4.9,4.9,5.1,4.9,5.0,5.2,4.8,4.9,5.0,5.0};
ablesefehler=0.05;
messfehler=0.05;
systematischerFehler=-0.2;

dann folgt mit

messwerte=messwerte+systematischerFehler; (*systematischen Fehler korrigieren*)
mittelwert=Mean[messwerte] (*Mittelwert bilden*)
standartabweichung=StandardDeviation[messwerte]; (*Standartabweichung bilden*)
vertrauensintervall=standartabweichung/Sqrt[Length[messwerte]]; (*Vertrauensbereich bilden mit Standartabweichung durch die Wurzel der Anzahl der Messwerte*)
unsicherheit=Sqrt[vertrauensintervall^2+ablesefehler^2+messfehler^2] (*alles geometrisch mitteln für die Unsicherheit*)

unser Ergebnis ist also (4.79+-0.08)
Wir können uns das auch mal in einem Plot visualisieren:

Show[ListPlot[messwerte],Plot[mittelwert,{x,0,Length[messwerte]}]]

Vollständiges Beispiel zur Berechnung einer Regression und “ansprechende” visuelle Ausgabe des Ergebnisses

xError={0.05,0.11,0.01,0.06,0.08,0.06,0.04,0.06,0.01,0.02};
yError={0.32,0.31,0.03,0.16,0.18,0.3,0.25,0.39,0.52,0.12};
data={{0.45,1.72},{1.09,2.08},{1.49,1.22},{1.95,0.14},{2.57,-0.85},{3.04,-1.76},{3.52,-1.75},{3.94,-1.59},{4.49,-1.84},{4.97,-0.45}};

fit=NonlinearModelFit[data,A*Sin[x+ϕ],{A,ϕ},x,Weights->1/yError^2]

fit["ParameterTable"]
fit["AdjustedRSquared"]
fit["ANOVATable"]
fit["CovarianceMatrix"]//MatrixForm

Show[Plot[fit["BestFit"],{x,0,5}],ListPlot[data]]

Needs["ErrorBarPlots`"]

errorData=Table[{data[[i]],ErrorBar[xError[[i]],yError[[i]]]},{i,10}]

ErrorListPlot[errorData]

Show[ErrorListPlot[errorData],Plot[fit["BestFit"],{x,0,5}]]

Das folgende wurde in dieser Einführung nicht besprochen, aber zeigt wie man den Plot noch sehr ausschmücken kann.

Show[ErrorListPlot[errorData,PlotTheme->"Scientific",PlotStyle->Gray],Plot[fit["BestFit"],{x,-0.5,5.5},PlotStyle->Red],PlotRange->{{0,5},{-2.2,2.2}},ImageSize->Large]

Show[ErrorListPlot[errorData,PlotTheme->"Scientific",PlotStyle->Gray],Plot[fit["BestFit"],{x,-0.5,5.5},PlotStyle->Orange],PlotRange->{{0,5},{-2.2,2.2}},ImageSize->Large,Epilog->Inset[Framed[LineLegend[{Orange},{"Nichtlinearer Fit\n"<>ToString[A*Sin[x+ϕ],TraditionalForm]<>"\nA=(2.05±0.10)m\nϕ=(1.02±0.03)°\n(R^2)=0.994458
(χ^2)/dof=1.04041"}],Background->White],{0,0},{Left,Top}]]

Show[ErrorListPlot[errorData,PlotTheme->"Scientific",PlotStyle->Gray],Plot[fit["BestFit"],{x,-0.5,5.5},PlotStyle->Orange],Plot[Evaluate[Re[fit["SinglePredictionBands",ConfidenceLevel->0.683]]],{x,-0.5,5.5},PlotStyle->Opacity[0.3,Orange],FillingStyle->Opacity[0.1,Orange],Filling->{1->{2}}],PlotRange->{{0,5},{-3,3}},ImageSize->Large,Epilog->Inset[Framed[LineLegend[{Orange},{"Nichtlinearer Fit\n"<>ToString[A*Sin[x+ϕ],TraditionalForm]<>"\nA=(2.05±0.10)m\nϕ=(1.02±0.03)°\n(R^2)=0.994458
(χ^2)/dof=1.04041"}],Background->White],{0,0},{Left,Top}],FrameLabel->{"x","y=f(x)"},PlotLabel->"Meine erste Mathematica Regression"]