def test_concat(self):
p = Project()
p.data["a"] = Quantity("a")
p.data["a"].value = np.float_([1, 2, 3])
p.data["b"] = Quantity("b")
p.data["b"].value = np.float_(4)
p.concat("c", "a", "b")
self.assertTrue((p.data["c"].value == np.float_([1, 2, 3, 4])).all())
def test_formula(self):
p = Project()
p.data["U_I"] = Quantity("U_I")
p.data["I_I"] = Quantity("I_I")
u_err = Symbol("U_I_err", positive=True)
i_err = Symbol("I_I_err", positive=True)
p.data["Z_I"] = Quantity("Z_I", "Impedanz")
p.data["Z_I"].error_formula = u_err * i_err + p.data["U_I"] * p.data["I_I"]**2
self.assertEqual(p.formula("Z_I",True), r"\sigma{\left (Z_{I} \right )} = I_{I}^{2} U_{I} + \sigma{\left (I_{I} \right )} \sigma{\left (U_{I} \right )}")
def test_concat(self):
p = Project()
p.data["a"] = Quantity("a")
p.data["a"].value = np.float_([1, 2, 3])
p.data["b"] = Quantity("b")
p.data["b"].value = np.float_(4)
p.concat("c", "a", "b")
self.assertTrue((p.data["c"].value == np.float_([1, 2, 3, 4])).all())
def test_plot(self):
p = Project()
p.data["x"]=Quantity("x")
p.data["y"]=Quantity("y")
p.data["y"].value_prefUnit = si["ms"]
p.data["x"].value = np.float_([0,1,2,3,4,5])
p.data["x"].error = np.float_([0.1,0.1,0.2,0.3,0.4,0.3])
p.data["x"].dim = Dimension(time=1)
p.data["y"].value = np.float_([1,2.3,1.8,3.4,4.5,8])
p.data["y"].dim = Dimension(time=1)
p.plot(("x","y"))
def test_MeanValue(self):
p = Project()
# test unweighted mean value
p.data["a"]=Quantity("a")
p.data["a"].value = np.float_([3,4,5,6,7,8])
p.data["a"].dim = Dimension()
p.mean_value("m","a",longname="Mittelwert")
self.assertEqual(p.data["m"].name, "m")
self.assertEqual(p.data["m"].longname, "Mittelwert")
self.assertTrue(np.fabs(p.data["m"].value - 5.5)<0.000001)
self.assertTrue(np.fabs(p.data["m"].error - 0.84876886033) < 0.000001)
self.assertEqual(p.data["m"].value_formula, "standard mean value")
self.assertEqual(p.data["m"].dim, Dimension())
# test weighted mean value
p = Project()
p.data["a"]=Quantity("a")
p.data["b"]=Quantity("b")
p.data["a"].value = np.float_([3,4])
p.data["a"].error = np.float_([0.3,0.4])
p.data["a"].dim = Dimension(length=1)
p.data["b"].value = np.float_(7)
p.data["b"].error = np.float_(2)
p.data["b"].dim = Dimension(length=1)
p.mean_value("n","a","b",longname="Mittel")
self.assertEqual(p.data["n"].name, "n")
self.assertEqual(p.data["n"].longname, "Mittel")
self.assertTrue(np.fabs(p.data["n"].value - 3.41167192429)<0.000001)
self.assertTrue(np.fabs(p.data["n"].error - 0.23829044123) < 0.000001)
self.assertEqual(p.data["n"].value_formula, "standard weighted mean value")
self.assertEqual(p.data["n"].dim, Dimension(length=1))
def test_formula(self):
p = Project()
p.data["U_I"] = Quantity("U_I")
p.data["I_I"] = Quantity("I_I")
u_err = Symbol("U_I_err", positive=True)
i_err = Symbol("I_I_err", positive=True)
p.data["Z_I"] = Quantity("Z_I", "Impedanz")
p.data["Z_I"].error_formula = u_err * i_err + p.data["U_I"] * p.data[
"I_I"]**2
self.assertEqual(
p.formula("Z_I", True),
r"\sigma{\left (Z_{I} \right )} = I_{I}^{2} U_{I} + \sigma{\left (I_{I} \right )} \sigma{\left (U_{I} \right )}"
)
def test_assignment(self):
p = Project()
small=0.0000001
# test single Assignments
a = commands.Assignment("r","Radius")
a.value = "12"
a.value_unit = "mm"
a.uncert = "1/1000"
a.uncert_unit = "m"
a.execute(p)
self.assertEqual(p.data["r"].name, "r")
self.assertEqual(p.data["r"].longname, "Radius")
self.assertTrue(abs(p.data["r"].value - 0.012) < small)
self.assertEqual(p.data["r"].value_prefUnit, si["mm"])
self.assertEqual(p.data["r"].value_depend, None)
self.assertEqual(p.data["r"].dim, Dimension(length=1))
self.assertTrue(abs(p.data["r"].uncert - 0.001) < small)
self.assertEqual(p.data["r"].uncert_prefUnit, si["m"])
self.assertEqual(p.data["r"].uncert_depend, None)
b = commands.Assignment("h","Höhe")
b.value = "3"
b.value_unit = "dm"
b.uncert = "4"
b.uncert_unit = "cm"
b.execute(p)
self.assertEqual(p.data["h"].name, "h")
self.assertEqual(p.data["h"].longname, "Höhe")
self.assertTrue(abs(p.data["h"].value - 0.3) < small)
self.assertEqual(p.data["h"].value_prefUnit, si["dm"])
self.assertEqual(p.data["h"].value_depend, None)
self.assertEqual(p.data["h"].dim, Dimension(length=1))
self.assertTrue(abs(p.data["h"].uncert - 0.04) < small)
self.assertEqual(p.data["h"].uncert_prefUnit, si["cm"])
self.assertEqual(p.data["h"].uncert_depend, None)
# test calculation
c = commands.Assignment("V","Volumen")
c.value = "pi*r**2*h"
c.execute(p)
self.assertEqual(p.data["V"].name, "V")
self.assertEqual(p.data["V"].longname, "Volumen")
self.assertTrue(abs(p.data["V"].value - 0.0001357168) < small)
self.assertEqual(p.data["V"].value_prefUnit, None)
self.assertEqual(p.data["V"].value_depend, sympy.pi*p.data["r"]**2*p.data["h"])
self.assertEqual(p.data["V"].dim, Dimension(length=3))
self.assertTrue(abs(p.data["V"].uncert - 0.00002896705) < small)
self.assertEqual(p.data["V"].uncert_prefUnit, None)
self.assertEqual(p.data["V"].uncert_depend, sympy.sqrt((Symbol("r_err",positive=True)*sympy.pi*2*p.data["r"]*p.data["h"])**2 + (sympy.pi*Symbol("h_err",positive=True)*p.data["r"]**2)**2))
# test dimension mismatch
d = commands.Assignment("V","Vol2")
d.value = "50"
d.value_unit = "s"
d.uncert = "50"
d.uncert_unit = "A*s"
self.assertRaises(DimensionError, d.execute, p)
# test replacing quantity
e = commands.Assignment("V","Vol3")
e.value = "50"
e.value_unit = "s"
e.execute(p)
self.assertEqual(p.data["V"].name, "V")
self.assertEqual(p.data["V"].longname, "Vol3")
self.assertTrue(abs(p.data["V"].value - 50) < small)
self.assertEqual(p.data["V"].value_prefUnit, si["s"])
self.assertEqual(p.data["V"].value_depend, None)
self.assertEqual(p.data["V"].dim, Dimension(time=1))
self.assertTrue(p.data["V"].uncert is None)
self.assertTrue(p.data["V"].uncert_prefUnit is None)
self.assertTrue(p.data["V"].uncert_depend is None)
# test p.data set
f = commands.Assignment("y","Werte")
f.value = ["12","13","14"]
f.value_unit = "C"
f.uncert = ["0.5","0.4","1e-1"]
f.uncert_unit = "C"
f.execute(p)
self.assertEqual(p.data["y"].name, "y")
self.assertEqual(p.data["y"].longname, "Werte")
self.assertTrue((np.fabs(p.data["y"].value - np.float_([12,13,14])).all() < small).all())
self.assertEqual(p.data["y"].value_prefUnit, si["C"])
self.assertEqual(p.data["y"].value_depend, None)
self.assertEqual(p.data["y"].dim, Dimension(current=1,time=1))
self.assertTrue((np.fabs(p.data["y"].uncert - np.float_([0.5,0.4,0.1])) < small).all())
self.assertEqual(p.data["y"].uncert_prefUnit, si["C"])
self.assertEqual(p.data["y"].uncert_depend, None)
def test_MeanValue(self):
p = Project()
# test unweighted mean value
p.data["a"] = Quantity("a")
p.data["a"].value = np.float_([3, 4, 5, 6, 7, 8])
p.data["a"].dim = Dimension()
p.mean_value("m", "a", longname="Mittelwert")
self.assertEqual(p.data["m"].name, "m")
self.assertEqual(p.data["m"].longname, "Mittelwert")
self.assertTrue(np.fabs(p.data["m"].value - 5.5) < 0.000001)
self.assertTrue(np.fabs(p.data["m"].error - 0.84876886033) < 0.000001)
self.assertEqual(p.data["m"].value_formula, "standard mean value")
self.assertEqual(p.data["m"].dim, Dimension())
# test weighted mean value
p = Project()
p.data["a"] = Quantity("a")
p.data["b"] = Quantity("b")
p.data["a"].value = np.float_([3, 4])
p.data["a"].error = np.float_([0.3, 0.4])
p.data["a"].dim = Dimension(length=1)
p.data["b"].value = np.float_(7)
p.data["b"].error = np.float_(2)
p.data["b"].dim = Dimension(length=1)
p.mean_value("n", "a", "b", longname="Mittel")
self.assertEqual(p.data["n"].name, "n")
self.assertEqual(p.data["n"].longname, "Mittel")
self.assertTrue(np.fabs(p.data["n"].value - 3.41167192429) < 0.000001)
self.assertTrue(np.fabs(p.data["n"].error - 0.23829044123) < 0.000001)
self.assertEqual(p.data["n"].value_formula,
"standard weighted mean value")
self.assertEqual(p.data["n"].dim, Dimension(length=1))
def test_fit(self):
# test fit_scipy on its own
a = Quantity("a")
a.value = np.float_([1,3,5,6,7,9])
b = Quantity("b")
b.value = np.float_([2.3,4,5.5,6,9.2,10.5])
c = Quantity("c")
c.value = np.float_(1)
d = Quantity("d")
d.value = np.float_(1)
f = a*c+d
popt,perr = (sc.fit(a,b,f,[c,d]))
small = 0.0001
self.assertTrue(abs(popt[0] - 1.05184) < small)
self.assertTrue(abs(perr[0] - 0.1328) < small)
self.assertTrue(abs(popt[1] - 0.81551) < small)
self.assertTrue(abs(perr[1] - 0.7684) < small)
# test fit command
small = 0.001
p = Project()
g = commands.Assignment("x")
g.value = ["1","2","3"]
g.value_unit = "A"
g.execute(p)
g = commands.Assignment("y")
g.value = ["6","3","2.1"]
g.value_unit = "C"
g.error = ["1","1","2"]
g.error_unit = "1e-1*C"
g.execute(p)
h = commands.Assignment("m")
h.value = "1"
h.value_unit = "s"
h.execute(p)
i = commands.Assignment("b")
i.value = "1"
i.value_unit = "C"
i.execute(p)
p.fit("m*x+b",("x","y"),["m","b"])
self.assertTrue(abs(p.data["m"].value - (-2.3)) < small)
self.assertTrue(abs(p.data["m"].error - 0.7) < small)
self.assertTrue(abs(p.data["b"].value - 8.06667) < small)
self.assertTrue(abs(p.data["b"].error - 1.257) < small)
p.fit("m*x+b",("x","y"),["m","b"],weighted=False)
self.assertTrue(abs(p.data["m"].value - (-1.95)) < small)
self.assertTrue(abs(p.data["m"].error - 0.6062) < small)
self.assertTrue(abs(p.data["b"].value - 7.6) < small)
self.assertTrue(abs(p.data["b"].error - 1.31) < small)
p.data["y"].error = None
self.assertRaises(RuntimeError,p.fit,"m*x+b",("x","y"),["m","b"],weighted=True)
from errorpro.project import Project
from IPython.core.magic import register_line_cell_magic
import pydoc
from IPython import get_ipython
ipython = get_ipython()
ipython.magic("matplotlib inline")
default_project = Project()
def wrappedHelpText(wrappedFunc):
def decorator(f):
f.__doc__ = 'This method wraps the following method:\n\n' + pydoc.text.document(
wrappedFunc)
return f
return decorator
@register_line_cell_magic
def calc(line, cell=None):
if cell is None:
default_project.calc(line)
else:
default_project.calc(cell)
@wrappedHelpText(default_project.save)
def save(*args, **kwargs):
return default_project.save(*args, **kwargs)
def test_fit(self):
# test fit_scipy on its own
a = Quantity("a")
a.value = np.float_([1, 3, 5, 6, 7, 9])
b = Quantity("b")
b.value = np.float_([2.3, 4, 5.5, 6, 9.2, 10.5])
c = Quantity("c")
c.value = np.float_(1)
d = Quantity("d")
d.value = np.float_(1)
f = a * c + d
popt, perr = (sc.fit(a, b, f, [c, d]))
small = 0.0001
self.assertTrue(abs(popt[0] - 1.05184) < small)
self.assertTrue(abs(perr[0] - 0.1328) < small)
self.assertTrue(abs(popt[1] - 0.81551) < small)
self.assertTrue(abs(perr[1] - 0.7684) < small)
# test fit command
small = 0.001
p = Project()
g = commands.Assignment("x")
g.value = ["1", "2", "3"]
g.value_unit = "A"
g.execute(p)
g = commands.Assignment("y")
g.value = ["6", "3", "2.1"]
g.value_unit = "C"
g.error = ["1", "1", "2"]
g.error_unit = "1e-1*C"
g.execute(p)
h = commands.Assignment("m")
h.value = "1"
h.value_unit = "s"
h.execute(p)
i = commands.Assignment("b")
i.value = "1"
i.value_unit = "C"
i.execute(p)
p.fit("m*x+b", ("x", "y"), ["m", "b"])
self.assertTrue(abs(p.data["m"].value - (-2.3)) < small)
self.assertTrue(abs(p.data["m"].error - 0.7) < small)
self.assertTrue(abs(p.data["b"].value - 8.06667) < small)
self.assertTrue(abs(p.data["b"].error - 1.257) < small)
p.fit("m*x+b", ("x", "y"), ["m", "b"], weighted=False)
self.assertTrue(abs(p.data["m"].value - (-1.95)) < small)
self.assertTrue(abs(p.data["m"].error - 0.6062) < small)
self.assertTrue(abs(p.data["b"].value - 7.6) < small)
self.assertTrue(abs(p.data["b"].error - 1.31) < small)
p.data["y"].error = None
self.assertRaises(RuntimeError,
p.fit,
"m*x+b", ("x", "y"), ["m", "b"],
weighted=True)
