Computerpraktikum - Lineare Regression by Heiko Dumlich

Aufgabe 1

Aufgabe 1 a

Off[General::spelll];
<< Statistics`DataManipulation`
<< Graphics`Graphics`
\(LinReg[daten_] := 
      Module[{x, y, Δy, 
          S, Δa0, Δb0, a0, b0, n, x2, R2, ny, 
          ymit, nΔy}, 
n = 
          Length[daten]; 
x = 
          Column[daten, 1]; 
y = 
          Column[daten, 2]; Δy = 
          Column[daten, 
            3]; 
S = ∑\+\(i = 1\)\%n 
                  1/\((Δy[[
                        i]])\)^2*\(∑\+\(i = 1\)\%n\((x[[
                          i]])\)^2/\((Δy[[i]])\)^2\) - \((∑\+\(i = 1\)\%n 
                      x[[
                      i]]/\((Δy[[i]])\)^2)\)^2; 
        a0 = 1/S*\((∑\+\(i = 1\)\%n\((x[[
                            i]])\)^2/\((Δy[[i]])\)^2*\(∑\+\(i = 1\)\%n 
                          y[[
                          i]]/\((Δy[[i]])\)^2\) - ∑\+\(i = 1\)\%n 
                        x[[
                        i]]/\((Δy[[i]])\)^2*\(∑\+\(i = 1\)\%n 
                          x[[i]]*
                        y[[
                            i]]/\((Δy[[i]])\)^2\))\); 
        b0 = 1/S*\((∑\+\(i = 1\)\%n 
                      1/\((Δy[[
                            i]])\)^2*\(∑\+\(i = 1\)\%n x[[i]]*
                        y[[
                            i]]/\((Δy[[i]])\)^2\) - ∑\+\(i = 1\)\%n 
                        x[[
                        i]]/\((Δy[[i]])\)^2*\(∑\+\(i = 1\)\%n 
                          y[[
                          i]]/\((Δy[[i]])\)^2\))\); Δa0 = 
          Sqrt[1/S*\(∑\+\(i = 1\)\%n\((x[[i]])\)^2/\((Δy[[i]])\)^2\)]; 
Δb0 = 
          Sqrt[1/S*\(∑\+\(i = 1\)\%n 
                  1/\((Δy[[i]])\)^2\)]; 
Print["Berechnung der Fehler aus den Eingangsfehlern"]; 
Print[
          TableForm[{{"", "Wert", "Fehler"}, {"Steigung b", 
                b0, Δb0}, {"Achsenabschnitt a", 
                a0, Δa0}}]]; 
\ \ \ \ \ \ \ ny = Length[y]; 
        nΔy = Length[Δy]; 
        ymit = \(∑\+\(i = 1\)\%n\((y[[i]])\)/\((Δy[[i]])\)^2\)\/\(∑\+\(i = 1\)\%n 1/\((Δy[[i]])\)^2\); 
\ \ \ \ \ \ \ Print["Anzahl der Messwerte : "]; 
        Print[TableForm[{{"Messwertart", "Anzahl der Werte"}, {"  x", n}, {"  y", 
                ny}, {"σ[[i]] = Δy", nΔy}}]]; 
\ \ \ \ \ \ \ R2 = 
          1 - \((∑\+\(i = 1\)\%n\ \((\ \((y[[i]])\) - a0 - b0\ \((x[[i]])\)\ )\)^2\ \ /\((Δy[[i]])\)^2)\)\/\(∑\+\(i = 1\)\%n\((\((y[[i]])\) - ymit)\)\^2/\((Δy[[i]])\)^2\); Print["Bestimmtheitsmaß R²:", \ 
          R2]; 
\ \ \ \ \ \ \ x2 = \((∑\+\(i = 1\)\%n\ \((\ \((y[[i]])\) - a0 - 
                        b0\ \((x[[i]])\)\ )\)^2/\((Δy[[
                        i]])\)^2)\)/\((n - 
                2)\); 
\ \ Print["Chiquadrat: Χ²/(n-2) : ", 
          x2]; {b -> b0, Δb -> Δb0, 
          a -> a0, Δa -> Δa0}]\)

Aufgabe 1 b

linear  =  ReadList["linear.txt", {Real, Real, Real}]

regerg = LinReg[linear]

DisplayTogether[ErrorListPlot[linear], 
      Plot[Evaluate[{b t  + a,  (b +  Δb) t + 
                a + Δa, (b - Δb) t + 
                a - Δa} /. regerg], {t, 0, 18}, 
        PlotStyle -> {Dashing[{ .0}], Dashing[{0.01}], 
            Dashing[{ .01}]}], ImageSize  ->  600]

\(\(\((exponential\  = \ 
ReadList["exp.txt", {Real, Real, Real}])\);\)\)

\(\((linearisiert\  = \ 
          Replace[exponential, {xi_, yi_, Δyi_} -> {xi, 
                Log[yi], \((1/yi)\)*Δyi}, 2])\) // 
      TableForm[#, 
          TableHeadings -> {{}, {"x", "ln(y)", \*""Δln[y]=(1/y)Δy""}}] &\)

experg = LinReg[linearisiert]

DisplayTogether[ErrorListPlot[linearisiert], 
      Plot[Evaluate[{b t  + a,  (b +  Δb) t + 
                a + Δa, (b - Δb) t + 
                a - Δa} /. experg], {t, 0, 18}, 
        PlotStyle -> {Dashing[{ .0}], Dashing[{0.01}], 
            Dashing[{ .01}]}], ImageSize  ->  600]

Aufgabe 2

\(\(\((exponential\  = \ 
ReadList["exp.txt", {Real, Real, Real}])\)\  // 
        TableForm[#, 
            TableHeadings -> {{}, {"x", "y", "Δy"}}] &;\)\)

experg2 = LinReg[exponential]

DisplayTogether[ErrorListPlot[exponential], 
      Plot[Evaluate[{b t  + a,  (b +  Δb) t + 
                a + Δa, (b - Δb) t + 
                a - Δa} /. experg2], {t, 0, 18}, 
        PlotStyle -> {Dashing[{ .0}], Dashing[{0.01}], 
            Dashing[{ .01}]}], ImageSize  ->  600]

Die Ausgleichsgerade und Grenzgeraden dürfen hier natürlich nicht in dieser Form eingezeichnet werden, da wir einen exponentiellen Verlauf erkennen können. Somit müsste eine exponentielle Form der Grenzgeraden und Ausgleichsgerade gewählt werden, wenn man nicht auf logarithmische Skala wechseln möchte. Das Ergebnis ist zu begründen, indem wir von einer linearen Auswertung ausgegangen sind, jedoch einen exponentiellen Verlauf haben, somit ist Mathematica nicht in der Lage eine sinnvolle Ausgleichsgerade bzw. Grenzgeraden zu ziehen. Es zieht die Geraden so, als ob die Verteilung der Punkte eine Gerade ergeben würde. Wie man gut am Bestimmtheitsmaß (R^2) erkennen kann, welches mit (R^2)= 0,854698 viel weiter von 1 entfernt ist als die vorherigen Modelle (für die logarithmierte Exponentialfunktion: (R^2) =0.998766). Da das Bestimmtheitsmaß die "Güte" unseres Modelles beschreibt(wobei 1 den "besten" zu erreichenden Wert darstellt), können wir erkennen, dass dieses Modell im Gegensatz zu den vorherigen eine starke Verschlechterung darstellt (in diesem Falle sieht es sogar schlichtweg falsch aus).  Eine eindeutige Fehleinschätzung zeigt auch das (χ^2)/(n - 2) an, wobei ein Wert von 1 zu erwarten wäre. Für Werte größer als 1 , insbesondere bei diesem enorm großen Wert von (χ^2)/(n - 2) =118.032 , muss man davon ausgehen, dass das Modell falsch ist, Fehlerquellen übersehen wurden oder man ungenauer gemessen hat, als man geschätzt hatte, in unserem Falle wurde eine "Lineare Regression" auf einen exponentiellen Zusammenhang angewendet, womit der Fehler gefunden ist.

Aufgabe 3

Aufgabe 3 a

linear  =  ReadList["linear.txt", {Real, Real, Real}]

linear4 = {Column [linear, 1], Column [linear, 2], 
        4 Column [linear, 3]}

Transpose[linear4] // TableForm

alternativ mit Replace :

linear4a = 
      Replace[linear , {de_, df_, dg_} -> {de, df, 4 dg}, 2] // 
        TableForm

Aufgabe 3 b

\(LinRegalt[daten_] := 
      Module[{x, y, Δy, 
          S, Δa0, Δb0, a0, b0, n, R2, ny, ymit, 
          nΔy}, 
n = 
          Length[daten]; 
x = 
          Column[daten, 1]; 
y = 
          Column[daten, 2]; Δy = 
          Column[daten, 
            3]; 
S = ∑\+\(i = 1\)\%n 
                  1/\((Δy[[
                        i]])\)^2*\(∑\+\(i = 1\)\%n\((x[[
                          i]])\)^2/\((Δy[[i]])\)^2\) - \((∑\+\(i = 1\)\%n 
                      x[[
                      i]]/\((Δy[[i]])\)^2)\)^2; 
        a0 = 1/S*\((∑\+\(i = 1\)\%n\((x[[
                            i]])\)^2/\((Δy[[i]])\)^2*\(∑\+\(i = 1\)\%n 
                          y[[
                          i]]/\((Δy[[i]])\)^2\) - ∑\+\(i = 1\)\%n 
                        x[[
                        i]]/\((Δy[[i]])\)^2*\(∑\+\(i = 1\)\%n 
                          x[[i]]*
                        y[[
                            i]]/\((Δy[[i]])\)^2\))\); 
        b0 = 1/S*\((∑\+\(i = 1\)\%n 
                      1/\((Δy[[
                            i]])\)^2*\(∑\+\(i = 1\)\%n x[[i]]*
                        y[[
                            i]]/\((Δy[[i]])\)^2\) - ∑\+\(i = 1\)\%n 
                        x[[
                        i]]/\((Δy[[i]])\)^2*\(∑\+\(i = 1\)\%n 
                          y[[
                          i]]/\((Δy[[
                              i]])\)^2\))\); 
x2 = \((∑\+\(i = 1\)\%n\ \((\ \((y[[
                            i]])\) - a0 - 
                        b0\ \((x[[
                              i]])\)\ )\)^2/\((Δy[[i]])\)^2)\)/\((n - 
                2)\); 
Δa0 = 
          Sqrt[x2/S*\(∑\+\(i = 1\)\%n\((x[[i]])\)^2/\((Δy[[i]])\)^2\)]; 
Δb0 = 
          Sqrt[x2/S*\(∑\+\(i = 1\)\%n 
                  1/\((Δy[[i]])\)^2\)]; 
Print["Berechnung der Fehler aus den Eingangsfehlern"]; 
Print[
          TableForm[{{"", "Wert", "Fehler"}, {"Steigung b", 
                b0, Δb0}, {"Achsenabschnitt a", 
                a0, Δa0}}]]; 
\ \ \ \ \ \ \ ny = Length[y]; 
        nΔy = Length[Δy]; 
        ymit = \(∑\+\(i = 1\)\%n\((y[[i]])\)/\((Δy[[i]])\)^2\)\/\(∑\+\(i = 1\)\%n 1/\((Δy[[i]])\)^2\); 
\ \ \ \ \ \ \ Print["Anzahl der Messwerte : "]; 
        Print[TableForm[{{"Messwertart", "Anzahl der Werte"}, {"  x", n}, {"  y", 
                ny}, {"σ[[i]] = Δy", nΔy}}]]; 
\ \ \ \ \ \ \ R2 = 
          1 - \((∑\+\(i = 1\)\%n\ \((\ \((y[[i]])\) - a0 - b0\ \((x[[i]])\)\ )\)^2\ \ /\((Δy[[i]])\)^2)\)\/\(∑\+\(i = 1\)\%n\((\((y[[i]])\) - ymit)\)\^2/\((Δy[[i]])\)^2\); Print["Bestimmtheitsmaß R²:", \ 
          
          R2]; 
\ \ \ \ \ \ \ Print["Chiquadrat: Χ²/(n-2) : ", x2]; {b -> b0, Δb -> Δb0, 
          a -> a0, Δa -> Δa0}]\)

Aufgabe 3 c

linear  =  
        ReadList["linear.txt", {Real, Real, Real}];

regergalt = LinRegalt[linear]

DisplayTogether[ListPlot[Column[linear, {1, 2}]], 
      Plot[Evaluate[{b t  + a,  (b +  Δb) t + 
                a + Δa, (b - Δb) t + 
                a - Δa} /. regergalt], {t, 0, 18}, 
        PlotStyle -> {Dashing[{ .0}], Dashing[{0.01}], 
            Dashing[{ .01}]}], ImageSize  ->  600]

DisplayTogether[ErrorListPlot[linear], 
      Plot[Evaluate[{b t  + a,  (b +  Δb) t + 
                a + Δa, (b - Δb) t + 
                a - Δa} /. regergalt], {t, 0, 18}, 
        PlotStyle -> {Dashing[{ .0}], Dashing[{0.01}], 
            Dashing[{ .01}]}], ImageSize  ->  600]

linear4b  = Transpose[linear4];

regergalt4 = LinRegalt[linear4b]

DisplayTogether[ListPlot[Column[linear4b, {1, 2}]], 
      Plot[Evaluate[{b t  + a,  (b +  Δb) t + 
                a + Δa, (b - Δb) t + 
                a - Δa} /. regergalt4], {t, 0, 18}, 
        PlotStyle -> {Dashing[{ .0}], Dashing[{0.01}], 
            Dashing[{ .01}]}], ImageSize  ->  600]

DisplayTogether[ErrorListPlot[linear4b], 
      Plot[Evaluate[{b t  + a,  (b +  Δb) t + 
                a + Δa, (b - Δb) t + 
                a - Δa} /. regergalt4], {t, 0, 18}, 
        PlotStyle -> {Dashing[{ .0}], Dashing[{0.01}], 
            Dashing[{ .01}]}], ImageSize  ->  600]

regerg = LinReg[linear]

DisplayTogether[ErrorListPlot[linear], 
      Plot[Evaluate[{b t  + a,  (b +  Δb) t + 
                a + Δa, (b - Δb) t + 
                a - Δa} /. regerg], {t, 0, 18}, 
        PlotStyle -> {Dashing[{ .0}], Dashing[{0.01}], 
            Dashing[{ .01}]}], ImageSize  ->  600]

regerg4 = LinReg[linear4b]

DisplayTogether[ErrorListPlot[linear4b], 
      Plot[Evaluate[{b t  + a,  (b +  Δb) t + 
                a + Δa, (b - Δb) t + 
                a - Δa} /. regerg4], {t, 0, 18}, 
        PlotStyle -> {Dashing[{ .0}], Dashing[{0.01}], 
            Dashing[{ .01}]}], ImageSize  ->  600]

Aufgabe 3 d

Das erste Verfahren (1 a) benutzt nur die Fehler, die a-priori bekannt sind/"selbst geschaetzt wurden". Waehrend das 2. Verfahren (3 b) die Wichtung der Fehler beachtet, wobei der Fehler insgesamt "unbekannt" ist und nur die Wichtung der Fehler untereinander bekannt ist. Da fuer σ = 1 auch f[[i]] = σ[[i]] gilt, ist der Erwartungswert fuer (s^2)(in unserem Fall (s^2)= ((χ^2)/(n - 2))) auch gleich 1.Fuer grosse Abweichungen von (s^2) >>  1 waere das Modell falsch, unser Modell erscheint jedoch richtig und da wir ja f[[i]] = σ[[i]], wegen σ = 1 angenommen haben, erhalten wir auch die gleichen Werte fuer (R^2) und ((χ^2)/(n - 2)). Fuer die Grenzgeraden und Fehler folgen natuerlich verschiedene Werte, da die Fehler von 1 a a-priori gegeben wurden und somit im Falle der Vervierfachung sogar sehr viel groesser werden, waehrend die Vervierfachung bei 3 b keine Auswirkung zeigt (die Verrechnung mit ((χ^2)/(n - 2))gleicht dieses aus), da sich ja die Verhaeltnisse der Werte hierdurch nicht aendern, sondern nur der "totale" Wert des Fehlers (also, vervierfacht sich unser σ, "faellt" jedoch in der weiteren Betrachtung "heraus"). Somit liefert 3 b eine "bessere"/"menschlichere" Herangehensweise, da die Grenzgeraden an den Punkten und nicht an den geschaetzten a-priori Fehlern orientiert sind. Die Grenzgeraden von 1 a orientieren sich somit stark an den Fehlerbalken, obwohl wie man gut erkennen kann,dass hierdurch der Fehler stark ueberschaetzt wird. Dahingegen liefert die Punktbetrachtung und Grenzgeradenziehung von 3 b ein gutes Ergebnis, dass den Fehler meiner Meinung nach gut einschaetzt.

Aufgabe 3 e (Zusatzaufgabe)

<< Statistics`LinearRegression`
<<Statistics`NonlinearFit`

linearregress = Column[linear, {1, 2}];

reglinear = 
      Regress[linearregress, {1, x}, x,  
        Weights  ->  1/Column[linear, 3]^2]

regergalt = LinRegalt[linear]

regerg = LinReg[linear]

linear4regress = Column[linear4b, {1, 2}];

reglinear4 = 
      Regress[linear4regress, {1, x}, x, 
        Weights  ->  1/Column[linear, 3]^2]

regergalt4 = LinRegalt[linear4b]

regerg4 = LinReg[linear4b]

Mathematica verwendet also die Methode aus 3 b, wie man erkennen kann, stimmen die gefundenen Fehler mit denen von Mathematica ueberein. Mit dem Umrechnungsfaktor aus dem Skript(54) erhalten wir natuerlich auch fuer die aus 1 a erhaltenen Fehler das gleiche Ergebnis, da wir das ja im Grunde genommen nur bei 3 b geaendert hatten !

Aufgabe 4

Aufgabe 4 a

Es gilt für die Ursprungsgerade:
Y(X) = B*X , da A=0 (y-Achsenabschnitt A ist 0 bei der Ursprungsgeraden !),
somit gilt <Y[[i]]>=<B>*x[[i]],
für L(y[[i]]) folgt dann :
L(y[[i]])=\(TraditionalForm\`∏\+\(i = 1\)\%n\( 
              1\/\@\(2\ πσ[[i]]\^2\)\) 
          e\^\(-\((∑\+\(i = 1\)\%n\((\ \(\(y[[i]]\)\(-\)\) < B > \ x[[i]]\ )\)\^2\/\(2  σ[[i]]\^2\))\)\)\),
Daher wählen wir nun für \(TraditionalForm\`χ\^2\  = \ ∑\+\(i = 1\)\%n\((\ y[[i]] - \ \(\(^\)\(b\)\)\ x[[i]]\ )\)\^2\/σ[[i]]\^2\)(da für (χ^2)minimal wird L(y[[i]]) maximal !),
somit folgt für unser Minimum \(TraditionalForm\`0\  = \ \(∂\_\(\(^\)\(b\)\)\ χ\^2\  = \ ∑\+\(i = 1\)\%n x[[i]]\/σ[[i]]\^2*\((y[[
                    i]] - \ \(\(^\)\(b\)\)\ x[[i]])\)\)\),
daraus folgt nach umstellen nach ^b :
^b = \(TraditionalForm\`\(∑\+\(i = 1\)\%n\( x[[i]]\ y[[i]]\)\/σ[[i]]\^2\)\/\(∑\+\(i = 1\)\%n\(\( x[[i]]\^2\)\(\ \)\)\/σ[[i]]\^2\)\),
für den Fehler gilt:
\(TraditionalForm\`σ[[b]]\^2\  = \ ∑\+\(i = 1\)\%n\((∂\_\(y[[i]]\)\ \(\(^\)\(b\)\))\)\^2\ σ[[i]]\^2\),
daraus folgt:
\(TraditionalForm\`\(\(σ[[b]]\^2\)\(\ \)\(=\)\)\) \(TraditionalForm\`∑\+\(i = 1\)\%n\((\(x[[i]]\/σ[[i]]\^2\)\/\(∑\+\(i = 1\)\%n\(\( x[[i]]\^2\)\(\ \)\)\/σ[[i]]\^2\))\)\^2\ σ[[i]]\^2\)
woraus für unseren Fehler Δ^b = \(TraditionalForm\`\@σ[[b]]\^2\):
 Δ^b= \(TraditionalForm\`\@\(∑\+\(i = 1\)\%n\((\(x[[i]]\/σ[[i]]\^2\)\/\(∑\+\(i = 1\)\%n\(\( x[[i]]\^2\)\(\ \)\)\/σ[[i]]\^2\))\)\^2\ σ[[i]]\^2\)\)
 resultiert. Somit folgt für die zu zeigenden Größen:
 Parameter ^b = \(TraditionalForm\`\(∑\+\(i = 1\)\%n\( x[[i]]\ y[[i]]\)\/σ[[i]]\^2\)\/\(∑\+\(i = 1\)\%n x[[i]]\^2\/σ[[i]]\^2\)\),
 \(TraditionalForm\`s\^2 = \ \(χ\^2\/\((n - 2)\) = \ \(∑\+\(i = 1\)\%n\((\ y[[i]] - \ \(\(^\)\(b\)\)\ x[[i]]\ )\)\^2\/σ[[i]]\^2\)\/\((n - 2)\)\)\),
 Fehler  Δ^b= \(TraditionalForm\`\@\(∑\+\(i = 1\)\%n\((\(x[[i]]\/σ[[i]]\^2\)\/\(∑\+\(i = 1\)\%n\(\( x[[i]]\^2\)\(\ \)\)\/σ[[i]]\^2\))\)\^2\ σ[[i]]\^2\)\).

Aufgabe 4 b

\(LinRegursprungsgerade[daten_] := 
      Module[{x, y, Δy, 
          S, Δa0, Δb0, a0, b0, 
          n}, 
n = Length[daten]; 
x = 
          Column[daten, 1]; 
y = 
          Column[daten, 2]; 
Δy = 
          Column[daten, 
            3]; 
S = ∑\+\(i = 1\)\%n 
                  1/\((Δy[[
                        i]])\)^2*\(∑\+\(i = 1\)\%n\((x[[
                          i]])\)^2/\((Δy[[i]])\)^2\) - \((∑\+\(i = 1\)\%n 
                      x[[
                      i]]/\((Δy[[
                          i]])\)^2)\)^2; 
b0 = \(∑\+\(i = 1\)\%n\( x[[i]]\ y[[i]]\)\/Δy[[i]]\^2\)\/\(∑\+\(i = 1\)\%n x[[i]]\^2\/Δy[[i]]\^2\); 
Δb0 = \@\(∑\+\(i = 1\)\%n\((\((\(x[[i]]\/Δy[[i]]\^2\)\/\(∑\+\(i = 1\)\%n x[[i]]\^2\/Δy[[i]]\^2\))\)\^2\ Δy[[i]]\^2)\)\); 
Print["Berechnung der Fehler aus den Eingangsfehlern"]; 
Print[
          TableForm[{{"", "Wert", "Fehler"}, {"Steigung b", 
                b0, Δb0}}]]; 
\ \ \ \ \ \ \ \ ny = Length[y]; 
        nΔy = Length[Δy]; 
        ymit = \(∑\+\(i = 1\)\%n\((y[[i]])\)/\((Δy[[i]])\)^2\)\/\(∑\+\(i = 1\)\%n 1/\((Δy[[i]])\)^2\); 
\ \ \ \ \ \ \ Print["Anzahl der Messwerte : "]; 
        Print[TableForm[{{"Messwertart", "Anzahl der Werte"}, {"  x", n}, {"  y", 
                ny}, {"σ[[i]] = Δy", nΔy}}]]; 
\ \ \ \ \ \ \ R2 = 
          1 - \((∑\+\(i = 1\)\%n\ \((\ \((y[[i]])\) - b0\ \((x[[i]])\)\ )\)^2\ \ /\((Δy[[i]])\)^2)\)\/\(∑\+\(i = 1\)\%n\((\((y[[i]])\) - ymit)\)\^2/\((Δy[[i]])\)^2\); Print["Bestimmtheitsmaß R²:", \ 
          R2]; 
\ \ \ \ \ \ \ x2 = \((∑\+\(i = 1\)\%n\ \((\ \((y[[i]])\) - 
                        b0\ \((x[[i]])\)\ )\)^2/\((Δy[[i]])\)^2)\)/\((n - 2)\); 
\ \ Print["Chiquadrat: Χ²/(n-2) : ", 
          x2]; {b -> b0, Δb -> Δb0}]\)

regergurgsprungsgerade = LinRegursprungsgerade[linear]

DisplayTogether[ErrorListPlot[linear], 
      Plot[Evaluate[{b t ,  (b +  Δb) t, (b - Δb) t} /. regergurgsprungsgerade], {t, 0, 18}, 
        PlotStyle -> {Dashing[{ .0}], Dashing[{0.01}], 
            Dashing[{ .01}]}], ImageSize  ->  600]

Aufgabe 5 (Zusatzaufgabe) * (bitte nochmal nur Aufgabe 5 (Aufgabe 3) kompilieren, falls Fehler auftritt, habe wohl irgendwo eine globale Definition vergessen zu lokalisieren)

Aufgabe 1 in Matrixdarstellung

<< LinearAlgebra`MatrixManipulation`

\(LinRegmat[daten_] := 
      Module[{x, y, Δy, 
          S, Δa0, Δb0, adach, n, R2, x2, C1, ny, 
          nΔy, ymit}, 
n = 
          Length[daten]; 
x = 
          Column[daten, 1]; 
y = 
          Column[daten, 2]; 
Δy = 
          Column[daten, 3]; 
C1 = 
          Map[{1, #} &, x]; 
Vinf = 
          DiagonalMatrix[1/Δy\^2]; 
adach = 
          Inverse[Transpose[C1] . Vinf . C1] . Transpose[C1] . Vinf . 
            y; 
S = \((Δy\^\(-1\) . Δy\^\(-1\))\)\ \((x\^2 . Δy\^\(-2\))\) - \((x . Δy\^\(-2\))\)\^2; 
Δa0 = 
          Sqrt[1/S*
              x\^2 . Δy\^\(-2\)]; 
Δb0 = 
          Sqrt[1/S*Δy\^\(-1\) . Δy\^\(-1\)]; 
f = 
          adach[[1]] + 
            adach[[2]]\ x; 
Print["Berechnung der Fehler aus den Eingangsfehlern"]; 
Print[
          TableForm[{{"", "Wert", "Fehler"}, {"Steigung b", 
                adach[[2]], Δb0}, {"Achsenabschnitt a", 
                adach[[1]], Δa0}}]]; 
\ \ \ \ \ \ \ ny = Length[y]; 
        nΔy = Length[Δy]; 
        ymit = y . Δy\^\(-2\)\/Δy\^\(-1\) . Δy\^\(-1\); 
\ \ \ \ \ \ \ Print["Anzahl der Messwerte : "]; Print[
          TableForm[{{"Messwertart", "Anzahl der Werte"}, {"  x", 
                n}, {"  y", 
                ny}, {"σ[[i]] = Δy", nΔy}}]]; 
\ \ \ \ \ \ \ R2 = 
          1 - \(\(\ \)\(\((y - adach[[1]] - adach[[2]]\ x\ )\)\^2 . Δy\^\(-2\)\)\)\/\((y - ymit)\)\^2 . Δy\^\(-2\); 
        Print["Bestimmtheitsmaß R²:", \ 
          R2]; 
\ \ \ \ \ \ \ x2 = \((y - f)\) . 
              Vinf . \((y - f)\)/\((n - 
                2)\); 
\ \ Print["Chiquadrat: Χ²/(n-2) : ", 
          x2]; {b -> 
            adach[[2]], Δb -> Δb0, 
          a -> adach[[1]], Δa -> Δa0}]\)

linregmat = LinRegmat[linear]

DisplayTogether[ErrorListPlot[linear], 
      Plot[Evaluate[{b t  + a,  (b +  Δb) t + 
                a + Δa, (b - Δb) t + 
                a - Δa} /. linregmat], {t, 0, 18}, 
        PlotStyle -> {Dashing[{ .0}], Dashing[{0.01}], 
            Dashing[{ .01}]}], ImageSize  ->  600]

Aufgabe 5 (1 b) ist gleich wie Aufgabe 1 b, da wir die gleichen Werte uebergeben, erhalten wir die gleichen Graphen.

expergmat = LinRegmat[linearisiert]

DisplayTogether[ErrorListPlot[linearisiert], 
      Plot[Evaluate[{b t  + a,  (b +  Δb) t + 
                a + Δa, (b - Δb) t + 
                a - Δa} /. expergmat], {t, 0, 18}, 
        PlotStyle -> {Dashing[{ .0}], Dashing[{0.01}], 
            Dashing[{ .01}]}], ImageSize  ->  600]

Aufgabe 2 in Matrixdarstellung

experg2mat = LinRegmat[exponential]

DisplayTogether[ErrorListPlot[exponential], 
      Plot[Evaluate[{b t  + a,  (b +  Δb) t + 
                a + Δa, (b - Δb) t + 
                a - Δa} /. experg2mat], {t, 0, 18}, 
        PlotStyle -> {Dashing[{ .0}], Dashing[{0.01}], 
            Dashing[{ .01}]}], ImageSize  ->  600]

Aufgabe 3 in Matrixdarstellung

linear4c = 
        Map[{#[[1]], #[[2]], 
              4  #[[3]]} &, 
          linear];

\(LinRegmatalt[daten_] := 
      Module[{x, y, Δy, 
          S, Δa0, Δb0, adach, n, R2, x2, C1, ny, 
          nΔy, ymit}, 
n = 
          Length[daten]; 
x = 
          Column[daten, 1]; 
y = 
          Column[daten, 2]; 
Δy = 
          Column[daten, 3]; 
C1 = 
          Map[{1, #} &, x]; 
Vinf = 
          DiagonalMatrix[1/Δy\^2]; 
adach = 
          Inverse[Transpose[C1] . Vinf . C1] . Transpose[C1] . Vinf . 
            y; 
S = \((Δy\^\(-1\) . Δy\^\(-1\))\)\ \((x\^2 . Δy\^\(-2\))\) - \((x . Δy\^\(-2\))\)\^2; 
x2 = \((y - f)\) . 
              Vinf . \((y - f)\)/\((n - 
                2)\); 
Δa0 = 
          Sqrt[x2/S*
              x\^2 . Δy\^\(-2\)]; 
Δb0 = 
          Sqrt[x2/S*Δy\^\(-1\) . Δy\^\(-1\)]; 
f = 
          adach[[1]] + 
            adach[[2]]\ x; 
Print["Berechnung der Fehler aus den Eingangsfehlern"]; 
Print[
          TableForm[{{"", "Wert", "Fehler"}, {"Steigung b", 
                adach[[2]], Δb0}, {"Achsenabschnitt a", 
                adach[[1]], Δa0}}]]; 
\ \ \ \ \ \ \ ny = Length[y]; 
        nΔy = Length[Δy]; 
        ymit = y . Δy\^\(-2\)\/Δy\^\(-1\) . Δy\^\(-1\); 
\ \ \ \ \ \ \ Print["Anzahl der Messwerte : "]; Print[
          TableForm[{{"Messwertart", "Anzahl der Werte"}, {"  x", 
                n}, {"  y", 
                ny}, {"σ[[i]] = Δy", nΔy}}]]; 
\ \ \ \ \ \ \ R2 = 
          
          1 - \(\(\ \)\(\((y - adach[[1]] - adach[[2]]\ x\ )\)\^2 . Δy\^\(-2\)\)\)\/\((y - ymit)\)\^2 . Δy\^\(-2\); 
        Print["Bestimmtheitsmaß R²:", \ 
          R2]; 
\ \ \ \ \ \ \ \ \ Print["Chiquadrat: Χ²/(n-2) : ", 
          x2]; {b -> 
            adach[[2]], Δb -> Δb0, 
          a -> adach[[1]], Δa -> Δa0}]\)

regergaltmat = LinRegmatalt[linear]

DisplayTogether[ListPlot[Column[linear, {1, 2}]], 
      Plot[Evaluate[{b t  + a,  (b +  Δb) t + 
                a + Δa, (b - Δb) t + 
                a - Δa} /. regergaltmat], {t, 0, 18}, 
        PlotStyle -> {Dashing[{ .0}], Dashing[{0.01}], 
            Dashing[{ .01}]}], ImageSize  ->  600]

regergalt4mat = LinRegmatalt[linear4b]

DisplayTogether[ListPlot[Column[linear4b, {1, 2}]], 
      Plot[Evaluate[{b t  + a,  (b +  Δb) t + 
                a + Δa, (b - Δb) t + 
                a - Δa} /. regergalt4mat], {t, 0, 18}, 
        PlotStyle -> {Dashing[{ .0}], Dashing[{0.01}], 
            Dashing[{ .01}]}], ImageSize  ->  600]

Bitte nochmal nur Aufgabe 3 kompilieren, da ein Fehler auftritt, wenn man das ganze Notebook kompiliert an einer Stelle, erneute Kompilierung von Aufgabe 3 beseitigt den Fehler(leider keine Zeit den Fehler zu finden). Die weiteren Funktionen aus 1 b koennen in 5 (1b) gefunden werden .

Aufgabe 4 in Matrixdarstellung

\(LinRegursprungsgerademat[daten_] := 
      Module[{x, y, Δy, 
          S, Δa0, Δb0, adach, n, R2, x2, C1, ny, 
          nΔy, ymit}, 
n = 
          Length[daten]; 
x = 
          Column[daten, 1]; 
y = 
          Column[daten, 2]; 
Δy = 
          Column[daten, 3]; 
C1 = 
          Map[{1, #} &, x]; 
Vinf = 
          DiagonalMatrix[1/Δy\^2]; 
adach = 
          Inverse[Transpose[C1] . Vinf . C1] . Transpose[C1] . Vinf . 
            y; 
S = \((Δy\^\(-1\) . Δy\^\(-1\))\)\ \((x\^2 . Δy\^\(-2\))\) - \((x . Δy\^\(-2\))\)\^2; 
adach[[2]] = \((x\ y)\) . Δy\^\(-2\)\/x\^2 . Δy\^\(-2\); 
f = 
          adach[[2]]\ x; 
Δb0 = \@\(\((\((x . Δy\^\(-2\))\)\ \((x\^2 . Δy\^\(-2\))\)\^\(-1\))\)\^2\ Δy . Δy\); Δb0 = \@\(∑\+\(i = 1\)\%n\((\((\(x[[i]]\/Δy[[i]]\^2\)\/\(∑\+\(i = 1\)\%n x[[i]]\^2\/Δy[[i]]\^2\))\)\^2\ Δy[[i]]\^2)\)\); 
Print["Berechnung der Fehler aus den Eingangsfehlern"]; 
Print[
          TableForm[{{"", "Wert", "Fehler"}, {"Steigung b", 
                adach[[2]], Δb0}}]]; 
\ \ \ \ \ \ \ \ ny = Length[y]; 
        nΔy = Length[Δy]; 
        ymit = y . Δy\^\(-2\)\/Δy\^\(-1\) . Δy\^\(-1\); 
\ \ \ \ \ \ \ Print["Anzahl der Messwerte : "]; Print[
          TableForm[{{"Messwertart", "Anzahl der Werte"}, {"  x", 
                n}, {"  y", 
                ny}, {"σ[[i]] = Δy", nΔy}}]]; 
\ \ \ \ \ \ \ R2 = 
          1 - \(\(\ \)\(\((y - adach[[2]]\ x\ )\)\^2 . Δy\^\(-2\)\)\)\/\((y - ymit)\)\^2 . Δy\^\(-2\); 
        Print["Bestimmtheitsmaß R²:", \ 
          R2]; 
\ \ \ \ \ \ \ x2 = \((y - f)\) . 
              Vinf . \((y - f)\)/\((n - 
                2)\); 
\ \ Print["Chiquadrat: Χ²/(n-2) : ", 
          x2]; {b -> 
            adach[[2]], Δb -> Δb0}]\)

regergurgsprungsgerademat = LinRegursprungsgerademat[linear]

DisplayTogether[ErrorListPlot[linear], 
      Plot[Evaluate[{b t ,  (b +  Δb) t, (b - Δb) t} /. regergurgsprungsgerademat], {t, 0, 18}, 
        PlotStyle -> {Dashing[{ .0}], Dashing[{0.01}], 
            Dashing[{ .01}]}], ImageSize  ->  600]