new version of umath

uncertainties/core_new.py

@@ -7,7 +7,7 @@
 from math import sqrt, isnan
 from numbers import Real
 import sys
-from typing import Callable, Collection, Dict, Optional, Tuple, Union, TYPE_CHECKING
+from typing import Any, Callable, Collection, Dict, Optional, Tuple, Union, TYPE_CHECKING
 import uuid
 
 if TYPE_CHECKING:
@@ -322,13 +322,18 @@ def wrapped(*args, **kwargs):
         return wrapped
 
 
-def func_str_to_positional_func(func_str, nargs):
+def func_str_to_positional_func(func_str, nargs, eval_locals=None):
+    if eval_locals is None:
+        eval_locals = {}
     if nargs == 1:
-        def pos_func(x):  # noqa
-            return eval(func_str)
+        def pos_func(x):
+            eval_locals['x'] = x
+            return eval(func_str, None, eval_locals)
     elif nargs == 2:
-        def pos_func(x, y):  # noqa
-            return eval(func_str)
+        def pos_func(x, y):
+            eval_locals['x'] = x
+            eval_locals['y'] = y
+            return eval(func_str, None, eval_locals)
     else:
         raise ValueError(f'Only nargs=1 or nargs=2 is supported, not {nargs=}.')
     return pos_func
@@ -339,6 +344,7 @@ def pos_func(x, y):  # noqa
 
 def deriv_func_dict_positional_helper(
         deriv_funcs: Tuple[Optional[PositionalDerivFunc]],
+        eval_locals=None,
 ):
     nargs = len(deriv_funcs)
     deriv_func_dict = {}
@@ -349,7 +355,7 @@ def deriv_func_dict_positional_helper(
         elif callable(deriv_func):
             pass
         elif isinstance(deriv_func, str):
-            deriv_func = func_str_to_positional_func(deriv_func, nargs)
+            deriv_func = func_str_to_positional_func(deriv_func, nargs, eval_locals)
         else:
             raise ValueError(
                 f'Invalid deriv_func: {deriv_func}. Must be None, callable, or a '
@@ -373,9 +379,13 @@ class ToUFuncPositional(ToUFunc):
       and binary functions should use 'x' and 'y' as the two parameters respectively.
       An entry of None will cause the partial derivative to be calculated numerically.
     """
-    def __init__(self, deriv_funcs: Tuple[Optional[PositionalDerivFunc]]):
+    def __init__(
+            self,
+            deriv_funcs: Tuple[Optional[PositionalDerivFunc]],
+            eval_locals: Optional[Dict[str, Any]] = None,
+    ):
         ufloat_params = tuple(range(len(deriv_funcs)))
-        deriv_func_dict = deriv_func_dict_positional_helper(deriv_funcs)
+        deriv_func_dict = deriv_func_dict_positional_helper(deriv_funcs, eval_locals)
         super().__init__(ufloat_params, deriv_func_dict)
 
 

uncertainties/umath_new.py

@@ -0,0 +1,113 @@
+import math
+from numbers import Real
+import sys
+from typing import Union
+
+from uncertainties.core_new import UFloat, ToUFuncPositional
+
+
+UReal = Union[Real, UFloat]
+
+
+def acos(value: UReal) -> UReal: ...
+
+
+def acosh(value: UReal) -> UReal: ...
+
+
+def asinh(value: UReal) -> UReal: ...
+
+
+def atan(value: UReal) -> UReal: ...
+
+
+def atan2(x: UReal, y: UReal) -> UReal: ...
+
+
+def atanh(value: UReal) -> UReal: ...
+
+
+def cos(value: UReal) -> UReal: ...
+
+
+def cosh(value: UReal) -> UReal: ...
+
+
+def degrees(value: UReal) -> UReal: ...
+
+
+def erf(value: UReal) -> UReal: ...
+
+
+def erfc(value: UReal) -> UReal: ...
+
+
+def exp(value: UReal) -> UReal: ...
+
+
+# def log(value: UReal) -> UReal: ...
+
+
+def log10(value: UReal) -> UReal: ...
+
+
+def radians(value: UReal) -> UReal: ...
+
+
+def sin(value: UReal) -> UReal: ...
+
+
+def sinh(value: UReal) -> UReal: ...
+
+
+def sqrt(value: UReal) -> UReal: ...
+
+
+def tan(value: UReal) -> UReal: ...
+
+
+def tanh(value: UReal) -> UReal: ...
+
+
+def log_der0(*args):
+    """
+    Derivative of math.log() with respect to its first argument.
+
+    Works whether 1 or 2 arguments are given.
+    """
+    if len(args) == 1:
+        return 1 / args[0]
+    else:
+        return 1 / args[0] / math.log(args[1])  # 2-argument form
+
+
+deriv_dict = {
+    # In alphabetical order, here:
+    "acos": ("-1/math.sqrt(1-x**2)",),
+    "acosh": ("1/math.sqrt(x**2-1)",),
+    "asinh": ("1/math.sqrt(1+x**2)",),
+    "atan": ("1/(1+x**2)",),
+    "atan2": ('x/(x**2+y**2)', "-y/(x**2+y**2)"),
+    "atanh": ("1/(1-x**2)",),
+    "cos": ("-math.sin(x)",),
+    "cosh": ("math.sinh(x)",),
+    "degrees": ("math.degrees(1)",),
+    "erf": ("(2/math.sqrt(math.pi))*math.exp(-(x**2))",),
+    "erfc": ("-(2/math.sqrt(math.pi))*math.exp(-(x**2))",),
+    "exp": ("math.exp(x)",),
+    # "log": (log_der0, "-math.log(x, y) / y / math.log(y)"),
+    "log10": ("1/x/math.log(10)",),
+    "radians": ("math.radians(1)",),
+    "sin": ("math.cos(x)",),
+    "sinh": ("math.cosh(x)",),
+    "sqrt": ("0.5/math.sqrt(x)",),
+    "tan": ("1 + math.tan(x)**2",),
+    "tanh": ("1 - math.tanh(x)**2",),
+}
+
+this_module = sys.modules[__name__]
+
+for func_name, deriv_funcs in deriv_dict.items():
+    func = getattr(math, func_name)
+    ufunc = ToUFuncPositional(deriv_funcs, eval_locals={"math": math})(func)
+    setattr(this_module, func_name, ufunc)