move ulp and almosteq to new module unpythonic.numutil

Technologicat · Technologicat · commit ff6dadd9d6be · 2021-05-05T13:34:18.000+03:00
They are still available in the top-level namespace, as usual.
diff --git a/unpythonic/__init__.py b/unpythonic/__init__.py
@@ -35,6 +35,7 @@
 from .llist import *  # noqa: F401, F403
 from .mathseq import *  # noqa: F401, F403
 from .misc import *  # noqa: F401, F403
+from .numutil import *  # noqa: F401, F403
 from .seq import *  # noqa: F401, F403
 from .singleton import *  # noqa: F401, F403
 from .slicing import *  # noqa: F401, F403
diff --git a/unpythonic/mathseq.py b/unpythonic/mathseq.py
@@ -20,7 +20,6 @@
 
 __all__ = ["s", "imathify", "gmathify",
            "m", "mg",  # old names, pre-0.14.3, will go away in 0.15.0
-           "almosteq",
            "sadd", "ssub", "sabs", "spos", "sneg", "sinvert", "smul", "spow",
            "struediv", "sfloordiv", "smod", "sdivmod",
            "sround", "strunc", "sfloor", "sceil",
@@ -45,13 +44,13 @@
 
 from .it import take, rev, window
 from .gmemo import imemoize, gmemoize
+from .numutil import almosteq
 
 class _NoSuchType:
     pass
 
 # stuff to support float, mpf and SymPy expressions transparently
 #
-from sys import float_info
 from math import log as math_log, copysign, trunc, floor, ceil
 try:
     from mpmath import mpf, almosteq as mpf_almosteq
@@ -98,44 +97,6 @@ def sign(x):
     sign = _numsign
     _symExpr = _NoSuchType
 
-# TODO: Overhaul `almosteq` in v0.15.0, should work like mpf for consistency.
-# TODO: Also move it to `unpythonic.misc`, where `ulp` already is. Or make a `numutil`.
-def almosteq(a, b, tol=1e-8):
-    """Almost-equality that supports several formats.
-
-    The tolerance ``tol`` is used for the builtin ``float`` and ``mpmath.mpf``.
-
-    For ``mpmath.mpf``, we just delegate to ``mpmath.almosteq``, with the given
-    ``tol``. For ``float``, we use the strategy suggested in:
-
-        https://floating-point-gui.de/errors/comparison/
-
-    Anything else, for example SymPy expressions, strings, and containers
-    (regardless of content), is tested for exact equality.
-
-    **CAUTION**: Although placed in ``unpythonic.mathseq``, this function
-    **does not** support iterables; rather, it is a low-level tool that is
-    exposed in the public API in the hope it may be useful elsewhere.
-    """
-    if a == b:  # infinities and such, plus any non-float type
-        return True
-
-    if isinstance(a, mpf) and isinstance(b, mpf):
-        return mpf_almosteq(a, b, tol)
-    # compare as native float if only one is an mpf
-    elif isinstance(a, mpf) and isinstance(b, (float, int)):
-        a = float(a)
-    elif isinstance(a, (float, int)) and isinstance(b, mpf):
-        b = float(b)
-
-    if not all(isinstance(x, (float, int)) for x in (a, b)):
-        return False  # non-float type, already determined that a != b
-    min_normal = float_info.min
-    max_float = float_info.max
-    d = abs(a - b)
-    if a == 0 or b == 0 or d < min_normal:
-        return d < tol * min_normal
-    return d / min(abs(a) + abs(b), max_float) < tol
 
 def s(*spec):
     """Create a lazy mathematical sequence.
diff --git a/unpythonic/misc.py b/unpythonic/misc.py
@@ -5,16 +5,14 @@
            "pack", "namelambda", "timer",
            "getattrrec", "setattrrec",
            "Popper", "CountingIterator",
-           "ulp",
            "slurp", "async_raise", "callsite_filename", "safeissubclass"]
 
 from copy import copy
 from functools import partial
 from itertools import count
 import inspect
-from math import floor, log2
 from queue import Empty
-from sys import float_info, version_info
+from sys import version_info
 import threading
 from time import monotonic
 from types import CodeType, FunctionType, LambdaType, TracebackType
@@ -654,21 +652,6 @@ def __next__(self):
         self.count += 1
         return x
 
-# TODO: move to a new module unpythonic.numutil in v0.15.0.
-def ulp(x):  # Unit in the Last Place
-    """Given a float x, return the unit in the last place (ULP).
-
-    This is the numerical value of the least-significant bit, as a float.
-    For x = 1.0, the ULP is the machine epsilon (by definition of machine epsilon).
-
-    See:
-        https://en.wikipedia.org/wiki/Unit_in_the_last_place
-    """
-    eps = float_info.epsilon
-    # m_min = abs. value represented by a mantissa of 1.0, with the same exponent as x has
-    m_min = 2**floor(log2(abs(x)))
-    return m_min * eps
-
 def slurp(queue):
     """Slurp all items currently on a queue.Queue into a list.
 
diff --git a/unpythonic/numutil.py b/unpythonic/numutil.py
@@ -0,0 +1,67 @@
+# -*- coding: utf-8 -*-
+"""Low-level utilities for numerics."""
+
+__all__ = ["almosteq", "ulp"]
+
+from math import floor, log2
+import sys
+
+class _NoSuchType:
+    pass
+
+try:
+    from mpmath import mpf, almosteq as mpf_almosteq
+except ImportError:  # pragma: no cover, optional at runtime, but installed at development time.
+    # Can't use a gensym here since `mpf` must be a unique *type*.
+    mpf = _NoSuchType
+    mpf_almosteq = None
+
+
+# TODO: Overhaul `almosteq` in v0.15.0, should work like mpf for consistency.
+def almosteq(a, b, tol=1e-8):
+    """Almost-equality that supports several formats.
+
+    The tolerance ``tol`` is used for the builtin ``float`` and ``mpmath.mpf``.
+
+    For ``mpmath.mpf``, we just delegate to ``mpmath.almosteq``, with the given
+    ``tol``. For ``float``, we use the strategy suggested in:
+
+        https://floating-point-gui.de/errors/comparison/
+
+    Anything else, for example SymPy expressions, strings, and containers
+    (regardless of content), is tested for exact equality.
+    """
+    if a == b:  # infinities and such, plus any non-float type
+        return True
+
+    if isinstance(a, mpf) and isinstance(b, mpf):
+        return mpf_almosteq(a, b, tol)
+    # compare as native float if only one is an mpf
+    elif isinstance(a, mpf) and isinstance(b, (float, int)):
+        a = float(a)
+    elif isinstance(a, (float, int)) and isinstance(b, mpf):
+        b = float(b)
+
+    if not all(isinstance(x, (float, int)) for x in (a, b)):
+        return False  # non-float type, already determined that a != b
+    min_normal = sys.float_info.min
+    max_float = sys.float_info.max
+    d = abs(a - b)
+    if a == 0 or b == 0 or d < min_normal:
+        return d < tol * min_normal
+    return d / min(abs(a) + abs(b), max_float) < tol
+
+
+def ulp(x):  # Unit in the Last Place
+    """Given a float x, return the unit in the last place (ULP).
+
+    This is the numerical value of the least-significant bit, as a float.
+    For x = 1.0, the ULP is the machine epsilon (by definition of machine epsilon).
+
+    See:
+        https://en.wikipedia.org/wiki/Unit_in_the_last_place
+    """
+    eps = sys.float_info.epsilon
+    # m_min = abs. value represented by a mantissa of 1.0, with the same exponent as x has
+    m_min = 2**floor(log2(abs(x)))
+    return m_min * eps
diff --git a/unpythonic/tests/test_mathseq.py b/unpythonic/tests/test_mathseq.py
@@ -5,12 +5,11 @@
 
 from operator import mul
 from math import exp, trunc, floor, ceil
-from sys import float_info
 
 from ..mathseq import (s, imathify, gmathify,
                        sadd, smul, spow, cauchyprod,
                        primes, fibonacci,
-                       sign, log, almosteq)
+                       sign, log)
 from ..it import take, last
 from ..fold import scanl
 from ..gmemo import imemoize
@@ -46,31 +45,6 @@ def runtests():
             x = symbols("x", positive=True)
             test[log(symbolicExp(x)) == x]
 
-    with testset("almosteq"):
-        # For anything but floating-point inputs, it's exact equality.
-        test[almosteq("abc", "abc")]
-        test[not almosteq("ab", "abc")]
-
-        test[almosteq(1.0, 1.0 + ulp(1.0))]
-
-        # TODO: counterintuitively, need a large tolerance here, because when one operand is zero,
-        # TODO: the final tolerance is actually tol*min_normal.
-        min_normal = float_info.min
-        test[almosteq(min_normal / 2, 0, tol=1.0)]
-
-        too_large = 2**int(1e6)
-        test_raises[OverflowError, float(too_large), "UPDATE THIS, need a float overflow here."]
-        test[almosteq(too_large, too_large + 1)]  # works, because 1/too_large is very small.
-
-        try:
-            from mpmath import mpf
-        except ImportError:  # pragma: no cover
-            error["mpmath not installed in this Python, cannot test arbitrary precision input for mathseq."]
-        else:
-            test[almosteq(mpf(1.0), mpf(1.0 + ulp(1.0)))]
-            test[almosteq(1.0, mpf(1.0 + ulp(1.0)))]
-            test[almosteq(mpf(1.0), 1.0 + ulp(1.0))]
-
     # explicitly listed elements, same as a genexpr using tuple input (but supports infix math)
     with testset("s, convenience"):
         test[tuple(s(1)) == (1,)]
diff --git a/unpythonic/tests/test_misc.py b/unpythonic/tests/test_misc.py
@@ -6,15 +6,14 @@
 from operator import add
 from functools import partial
 from collections import deque
-from sys import float_info
 from queue import Queue
 from time import sleep
 import threading
 import sys
 
 from ..misc import (call, callwith, raisef, tryf, equip_with_traceback,
                     pack, namelambda, timer,
-                    getattrrec, setattrrec, Popper, CountingIterator, ulp, slurp,
+                    getattrrec, setattrrec, Popper, CountingIterator, slurp,
                     async_raise, callsite_filename, safeissubclass)
 from ..fun import withself
 from ..env import env
@@ -270,14 +269,6 @@ def __init__(self, x):
             test[it.count == k]
         test[it.count == 5]
 
-    # Unit in the Last Place, float utility
-    # https://en.wikipedia.org/wiki/Unit_in_the_last_place
-    with testset("ulp (unit in the last place; float utility)"):
-        test[ulp(1.0) == float_info.epsilon]
-        # test also at some base-2 exponent switch points
-        test[ulp(2.0) == 2 * float_info.epsilon]
-        test[ulp(0.5) == 0.5 * float_info.epsilon]
-
     with testset("slurp (drain a queue into a list)"):
         q = Queue()
         for k in range(10):
diff --git a/unpythonic/tests/test_numutil.py b/unpythonic/tests/test_numutil.py
@@ -0,0 +1,44 @@
+# -*- coding: utf-8 -*-
+
+from ..syntax import macros, test, test_raises, error  # noqa: F401
+from ..test.fixtures import session, testset
+
+import sys
+
+from ..numutil import almosteq, ulp
+
+def runtests():
+    with testset("ulp (unit in the last place; float utility)"):
+        test[ulp(1.0) == sys.float_info.epsilon]
+        # test also at some base-2 exponent switch points
+        test[ulp(2.0) == 2 * sys.float_info.epsilon]
+        test[ulp(0.5) == 0.5 * sys.float_info.epsilon]
+
+    with testset("almosteq"):
+        # For anything but floating-point inputs, it's exact equality.
+        test[almosteq("abc", "abc")]
+        test[not almosteq("ab", "abc")]
+
+        test[almosteq(1.0, 1.0 + ulp(1.0))]
+
+        # TODO: counterintuitively, need a large tolerance here, because when one operand is zero,
+        # TODO: the final tolerance is actually tol*min_normal.
+        min_normal = sys.float_info.min
+        test[almosteq(min_normal / 2, 0, tol=1.0)]
+
+        too_large = 2**int(1e6)
+        test_raises[OverflowError, float(too_large), "UPDATE THIS, need a float overflow here."]
+        test[almosteq(too_large, too_large + 1)]  # works, because 1/too_large is very small.
+
+        try:
+            from mpmath import mpf
+        except ImportError:  # pragma: no cover
+            error["mpmath not installed in this Python, cannot test arbitrary precision input for mathseq."]
+        else:
+            test[almosteq(mpf(1.0), mpf(1.0 + ulp(1.0)))]
+            test[almosteq(1.0, mpf(1.0 + ulp(1.0)))]
+            test[almosteq(mpf(1.0), 1.0 + ulp(1.0))]
+
+if __name__ == '__main__':  # pragma: no cover
+    with session(__file__):
+        runtests()
