$\boldsymbol{J}$ ist die Jacobimatrix von $\vec{f}$ nach $\vec{x}$.
uncertainties
¶
ufloat
, repräsentiert Wert mit Fehlerfrom uncertainties import ufloat
x = ufloat(5, 1)
y = ufloat(3, 1)
x + y
Korrelationen werden von uncertainties beachtet:
x = ufloat(3, 1)
y = ufloat(3, 1)
print(x**2 - y)
print(x**2 - x) # error is smaller!
uncertainties.unumpy
ergänzt numpy:
import numpy as np
import uncertainties.unumpy as unp
x = [1, 2, 3, 4, 5]
err = [0.1, 0.3, 0.1, 0.8, 1.0]
y = unp.uarray(x, err)
unp.cos(unp.exp(y))
Zugriff auf Wert und Standardabweichung mit n
und s
:
x = ufloat(5, 1)
print(x.n)
print(x.s)
Bei unumpy
mit nominal_values
und std_devs
x = unp.uarray([1, 2, 3], [0.3, 0.3, 0.1])
print(unp.nominal_values(x))
print(unp.std_devs(x))
Kann man natürlich auch abkürzen:
from uncertainties.unumpy import (nominal_values as noms,
std_devs as stds)
print(noms(x))
print(stds(x))
Man muss daran denken, die Funktionen aus unumpy zu benutzen (exp
, cos
, etc.)
np.cos(x)
from uncertainties import correlated_values
values = [1, 2]
cov = [[0.5, 0.25],
[0.25, 0.2]]
x, y = correlated_values(values, cov)
korrelierte Fit-Parameter führen zu nichts-sagenden Ergebnissen. Kontrolle: Kovarianzmatrix.
%matplotlib inline
from numpy.random import normal
import numpy as np
import matplotlib.pyplot as plt
plt.rcParams['figure.figsize'] = (10, 8)
plt.rcParams['font.size'] = 16
from scipy.optimize import curve_fit
from uncertainties import correlated_values, correlation_matrix
def f1(x, a, b):
return a * np.exp(b * x)
def f2(x, a, b, c):
return a * np.exp(b * x + c)
x = np.linspace(0, 2, 30)
y = 0.5 * np.exp(2 * x) + normal(0, 1, 30)
#params, cov = curve_fit(f1, x, y)
params, cov = curve_fit(f2, x, y)
params = correlated_values(params, cov)
for param in params:
print(param)
print()
print(cov)
plt.matshow(correlation_matrix(params), cmap='seismic')
plt.colorbar()
Man kann keine ufloat
s plotten:
x = np.linspace(0, 10)
y = unp.uarray(np.linspace(0, 5), 1)
#plt.plot(x, y, 'rx')
plt.errorbar(x, unp.nominal_values(y), yerr=unp.std_devs(y), fmt='rx')
SymPy importieren:
import sympy
Mathematische Variablen erzeugen mit var()
:
x, y, z = sympy.var('x y z')
x + y + z
Differenzieren mit diff()
:
f = x + y**3 - sympy.cos(z)**2
print(f.diff(x))
print(f.diff(y))
print(f.diff(z))
print(f.diff(z, z, z))
Eine Funktion, die automatisch die Fehlerformel generiert:
import sympy
def error(f, err_vars=None):
from sympy import Symbol, latex
s = 0
latex_names = dict()
if err_vars == None:
err_vars = f.free_symbols
for v in err_vars:
err = Symbol('latex_std_' + v.name)
s += f.diff(v)**2 * err**2
latex_names[err] = '\\sigma_{' + latex(v) + '}'
return latex(sympy.sqrt(s), symbol_names=latex_names)
E, q, r = sympy.var('E_x q r')
f = E + q**2 * r
print(f)
print(error(f))
print()