def test_numerical_example():
"Test specific numerical examples"
x = ufloat(3.14, 0.01)
result = umath_core.sin(x)
# In order to prevent big errors such as a wrong, constant value
# for all analytical and numerical derivatives, which would make
# test_fixed_derivatives_math_funcs() succeed despite incorrect
# calculations:
assert ("%.6f +/- %.6f" %
(result.nominal_value, result.std_dev) == "0.001593 +/- 0.010000")
# Regular calculations should still work:
assert ("%.11f" % umath_core.sin(3) == "0.14112000806")
def test_compound_expression():
"""
Test equality between different formulas.
"""
x = ufloat(3, 0.1)
# Prone to numerical errors (but not much more than floats):
assert umath_core.tan(x) == umath_core.sin(x) / umath_core.cos(x)
def test_math_module():
"Operations with the math module"
x = ufloat(-1.5, 0.1)
# The exponent must not be differentiated, when calculating the
# following (the partial derivative with respect to the exponent
# is not defined):
assert (x**2).nominal_value == 2.25
# Regular operations are chosen to be unchanged:
assert isinstance(umath_core.sin(3), float)
# factorial() must not be "damaged" by the umath_core module, so as
# to help make it a drop-in replacement for math (even though
# factorial() does not work on numbers with uncertainties
# because it is restricted to integers, as for
# math.factorial()):
assert umath_core.factorial(4) == 24
# fsum is special because it does not take a fixed number of
# variables:
assert umath_core.fsum([x, x]).nominal_value == -3
# Functions that give locally constant results are tested: they
# should give the same result as their float equivalent:
for name in umath_core.locally_cst_funcs:
try:
func = getattr(umath_core, name)
except AttributeError:
continue # Not in the math module, so not in umath_core either
assert func(x) == func(x.nominal_value)
# The type should be left untouched. For example, isnan()
# should always give a boolean:
assert type(func(x)) == type(func(x.nominal_value))
# The same exceptions should be generated when numbers with uncertainties
# are used:
# The type of the expected exception is first determined, because
# it varies between versions of Python (OverflowError in Python
# 2.6+, ValueError in Python 2.5,...):
try:
math.log(0)
except Exception, err_math: # "as", for Python 2.6+
# Python 3 does not make exceptions local variables: they are
# restricted to their except block:
err_math_args = err_math.args
exception_class = err_math.__class__
def test_math_module():
"Operations with the math module"
x = ufloat(-1.5, 0.1)
# The exponent must not be differentiated, when calculating the
# following (the partial derivative with respect to the exponent
# is not defined):
assert (x**2).nominal_value == 2.25
# Regular operations are chosen to be unchanged:
assert isinstance(umath_core.sin(3), float)
# Functions that give locally constant results are tested: they
# should give the same result as their float equivalent:
for name in umath_core.locally_cst_funcs:
try:
func = getattr(umath_core, name)
except AttributeError:
continue # Not in the math module, so not in umath_core either
assert func(x) == func(x.nominal_value)
# The type should be left untouched. For example, isnan()
# should always give a boolean:
assert type(func(x)) == type(func(x.nominal_value))
# The same exceptions should be generated when numbers with uncertainties
# are used:
# The type of the expected exception is first determined, because
# it varies between versions of Python (OverflowError in Python
# 2.6+, ValueError in Python 2.5,...):
try:
math.log(0)
except Exception, err_math: # "as", for Python 2.6+
err_math_args = err_math.args
exception_class = err_math.__class__
def test_math_module():
"Operations with the math module"
x = ufloat(-1.5, 0.1)
# The exponent must not be differentiated, when calculating the
# following (the partial derivative with respect to the exponent
# is not defined):
assert (x**2).nominal_value == 2.25
# Regular operations are chosen to be unchanged:
assert isinstance(umath_core.sin(3), float)
# factorial() must not be "damaged" by the umath_core module, so as
# to help make it a drop-in replacement for math (even though
# factorial() does not work on numbers with uncertainties
# because it is restricted to integers, as for
# math.factorial()):
assert umath_core.factorial(4) == 24
# fsum is special because it does not take a fixed number of
# variables:
assert umath_core.fsum([x, x]).nominal_value == -3
# Functions that give locally constant results are tested: they
# should give the same result as their float equivalent:
for name in umath_core.locally_cst_funcs:
try:
func = getattr(umath_core, name)
except AttributeError:
continue # Not in the math module, so not in umath_core either
assert func(x) == func(x.nominal_value)
# The type should be left untouched. For example, isnan()
# should always give a boolean:
assert type(func(x)) == type(func(x.nominal_value))
# The same exceptions should be generated when numbers with uncertainties
# are used:
## !! The Nose testing framework seems to catch an exception when
## it is aliased: "exc = OverflowError; ... except exc:..."
## surprisingly catches OverflowError. So, tests are written in a
## version-specific manner (until the Nose issue is resolved).
try:
math.log(0)
except ValueError as err_math:
# Python 3 does not make exceptions local variables: they are
# restricted to their except block:
err_math_args = err_math.args
else:
raise Exception('ValueError exception expected')
try:
umath_core.log(0)
except ValueError as err_ufloat:
assert err_math_args == err_ufloat.args
else:
raise Exception('ValueError exception expected')
try:
umath_core.log(ufloat(0, 0))
except ValueError as err_ufloat:
assert err_math_args == err_ufloat.args
else:
raise Exception('ValueError exception expected')
try:
umath_core.log(ufloat(0, 1))
except ValueError as err_ufloat:
assert err_math_args == err_ufloat.args
else:
raise Exception('ValueError exception expected')
