feat(Lib/math): nextafter, ulp (with test)

Author: litlighilit

src/pylib/Lib/math.nim

@@ -272,7 +272,10 @@ func comb*(n, k: int): int =
     nk = chkValNe k
   n_math.comb(nn, nk)
 
-# TODO: nextafter ulp
+func nextafter*[F: SomeFloat](x, y: F): F{.pysince(3,9).} = n_math.nextafter(x, y)
+func nextafter*[F: SomeFloat](x, y: F; steps: int|uint64): F{.pysince(3,12).} =
+  n_math.nextafter(x, y, steps)
+func ulp*[F: SomeFloat](x: F): F{.pysince(3,9).} = n_math.ulp(x)
 
 expN gcd
 expN lcm

src/pylib/Lib/math_impl/nextafter_step.nim

@@ -0,0 +1,103 @@
+
+
+from ./isX import isnan
+
+proc nextafter*(x, y: float;
+                         usteps: uint64): float =
+  ## [clinic input]
+  ## math.nextafter
+  ##
+  ##     x: double
+  ##     y: double
+  ##     /
+  ##
+  ##     steps: object = None
+  ##
+  ## Return the floating-point value the given number of steps after x towards y.
+  ##
+  ## If steps is not specified or is None, it defaults to 1.
+  ##
+  ## Raises a TypeError, if x or y is not a double, or if steps is not an integer.
+  ## Raises ValueError if steps is negative.
+  ## [clinic start generated code]
+  ## [clinic end generated code: output=cc6511f02afc099e input=7f2a5842112af2b4]
+  when defined(aix):
+    if x == y:
+      ##  On AIX 7.1, libm nextafter(-0.0, +0.0) returns -0.0.
+      ##            Bug fixed in bos.adt.libm 7.2.2.0 by APAR IV95512.
+      return (y)
+    if isnan(x):
+      return (x)
+    if isnan(y):
+      return (y)
+
+  ##  Conveniently, uint64_t and double have the same number of bits
+  ##  on all the platforms we care about.
+  ##  So if an overflow occurs, we can just use UINT64_MAX.
+
+  if usteps == 0:
+    return x
+  if isnan(x):
+    return x
+  if isnan(y):
+    return y
+  type
+    pun {.union.} = object # XXX: TODO: union object cannot run when nimvm
+      f: float64
+      i: uint64
+
+  var
+    ux = pun(f: x)
+    uy = pun(f: y)
+  if ux.i == uy.i:
+    return x
+  const sign_bit = 1'u64 shl 63
+  let
+    ax: uint64 = ux.i and not sign_bit
+    ay: uint64 = uy.i and not sign_bit
+  ##  opposite signs
+  if bool((ux.i xor uy.i) and sign_bit):
+    ##  NOTE: ax + ay can never overflow, because their most significant bit
+    ##  ain't set.
+    if ax + ay <= usteps:
+      return uy.f
+      ##  This comparison has to use <, because <= would get +0.0 vs -0.0
+      ##  wrong.
+    elif ax < usteps:
+      let res = pun(i: (uy.i and sign_bit) or (usteps - ax))
+      return res.f
+    else:
+      dec(ux.i, usteps)
+      return ux.f
+  elif ax > ay: ##  same sign
+    if ax - ay >= usteps:
+      dec(ux.i, usteps)
+      return ux.f
+    else:
+      return uy.f
+  else:
+    if ay - ax >= usteps:
+      inc(ux.i, usteps)
+      return ux.f
+    else:
+      return uy.f
+
+when culonglong is_not uint64:
+  proc nextafter*(x, y: float;
+                          usteps_ull: culonglong): float =
+    let usteps =
+      if usteps_ull >= UINT64_MAX:
+        ##  This branch includes the case where an error occurred, since
+        ##  (unsigned long long)(-1) = ULLONG_MAX >= UINT64_MAX. Note that
+        ##  usteps_ull can be strictly larger than UINT64_MAX on a machine
+        ##  where unsigned long long has width > 64 bits.
+        UINT64_MAX
+      else:
+        cast[uint64](usteps_ull)
+    nextafter(x, y, uint64 ustep)
+
+func nextafter*(x, y: float;
+                         steps: int): float =
+  if steps < 0:
+    raise newException(ValueError, "steps must be a non-negative integer")
+  nextafter(x, y, uint64 steps)

src/pylib/Lib/math_impl/nextafter_ulp.nim

@@ -0,0 +1,33 @@
+
+
+from ./platformUtils import CLike, clikeOr
+import ./patch/nextafter as n_nextafterLib
+import ./nextafter_step
+from ./isX import isnan, isinf
+
+when CLike:
+  {.push header: "<math.h>".}
+  proc c_nextafter(frm, to: c_double): c_double{.importc: "nextafter".}
+  proc c_nextafter(frm, to: c_float): c_float{.importc: "nextafterf".}
+  {.pop.}
+
+func nextafter*[F: SomeFloat](x, y: F): F =
+  clikeOr(
+    c_nextafter(x, y),
+    n_nextafterLib.nextafter(x, y)
+  )
+
+func nextafter*[F: SomeFloat](x, y: F; steps: int|uint64): F =
+  nextafter_step.nextafter(x, y, steps)
+
+func ulp*[F: SomeFloat](x: F): F =
+  bind nextafter
+  if isnan(x): return x
+  let x = abs(x)
+  if isinf(x): return x
+  result = nextafter(x, Inf)
+  if isinf(result):
+    # special case: x is the largest positive representable float 
+    result = nextafter(x, NegInf)
+    return x - result
+  result -= x

src/pylib/Lib/math_impl/patch/nextafter.nim

@@ -0,0 +1,67 @@
+
+##[
+  translated from https://github.com/scijs/nextafter/blob/master/nextafter.js
+]##
+
+#[
+The MIT License (MIT)
+
+Copyright (c) 2013 Mikola Lysenko
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.
+]#
+
+from ./ldexp_frexp/fromWords import fromWords
+from ./ldexp_frexp/toWords import toWords
+from std/math import pow, isNaN
+
+const
+  UINT_MAX = high uint32
+  dbl_SMALLEST_DENORM = pow(2.0, -1074)
+  #flt_SMALLEST_DENORM = pow(2, )
+
+template SMALLEST_DENORM[T](t: typedesc[T]): T =
+  when T is float64: dbl_SMALLEST_DENORM
+  else: {.error: "not impl".}  # XXX: rely on from/toWords, currently they're float64 only
+
+func nextafter*[F](x, y: F): F =
+  if isNaN(x) or isNaN(y):
+    return NaN
+  if x == y:
+    return x
+  if x == 0:
+    if y < 0:
+      return -F.SMALLEST_DENORM
+    else:
+      return F.SMALLEST_DENORM
+  var (hi, lo) = toWords(x)
+  if (y > x) == (x > 0):
+    if(lo == UINT_MAX):
+      hi += 1
+      lo = 0
+    else:
+      lo += 1
+  else:
+    if(lo == 0):
+      lo = UINT_MAX
+      hi -= 1
+    else:
+      lo -= 1
+
+  return fromWords(lo, hi)

src/pylib/Lib/n_math.nim

@@ -31,9 +31,11 @@ from ./math_impl/errnoUtils import
 from ./math_impl/ldexp import c_ldexp
 from ./math_impl/cbrt import cbrt
 import ./math_impl/frexp as frexpLib
+import ./math_impl/nextafter_ulp
 from ./errno import ERANGE, EDOM
 
 export cbrt
+export nextafter, ulp
 
 macro impPatch(sym) =
   #import ./math_impl/patch/sym

src/pylib/Lib/test/test_math.nim

@@ -3,6 +3,7 @@
 
 import ./import_utils
 importPyLib math
+importPyLib sys
 pyimport unittest
 from std/unittest import suiteStarted,  TestStatus, testStarted, suiteEnded, checkpoint, fail, TestResult,
   suite, test, check, expect
@@ -197,6 +198,100 @@ suite "classify":
       not (isfinite(F_INF))
       not (isfinite(F_NINF))
 
+suite "nextafter_ulp":
+  template assertEqualSign(a, b) =
+    let
+      sa = copysign(1.0, a)
+      sb = copysign(1.0, b)
+    check sa == sb
+  template assertIsNaN(x) =
+    check isnan(x)
+  test "nextafter":
+    #@requires_IEEE_754
+    def test_nextafter():
+        # around 2^52 and 2^63
+        assertEqual(math.nextafter(4503599627370496.0, -INF),
+                         4503599627370495.5)
+        assertEqual(math.nextafter(4503599627370496.0, INF),
+                         4503599627370497.0)
+        assertEqual(math.nextafter(9223372036854775808.0, 0.0),
+                         9223372036854774784.0)
+        assertEqual(math.nextafter(-9223372036854775808.0, 0.0),
+                         -9223372036854774784.0)
+
+        # around 1.0
+        assertEqual(math.nextafter(1.0, -INF),
+                         float_fromhex("0x1.fffffffffffffp-1"))
+        assertEqual(math.nextafter(1.0, INF),
+                         float_fromhex("0x1.0000000000001p+0"))
+        assertEqual(math.nextafter(1.0, -INF, steps=1),
+                         float_fromhex("0x1.fffffffffffffp-1"))
+        assertEqual(math.nextafter(1.0, INF, steps=1),
+                         float_fromhex("0x1.0000000000001p+0"))
+        assertEqual(math.nextafter(1.0, -INF, steps=3),
+                         float_fromhex("0x1.ffffffffffffdp-1"))
+        assertEqual(math.nextafter(1.0, INF, steps=3),
+                         float_fromhex("0x1.0000000000003p+0"))
+
+        # x == y: y is returned
+        for steps in range(1, 5):
+            assertEqual(math.nextafter(2.0, 2.0, steps=steps), 2.0)
+            assertEqualSign(math.nextafter(-0.0, +0.0, steps=steps), +0.0)
+            assertEqualSign(math.nextafter(+0.0, -0.0, steps=steps), -0.0)
+
+        # around 0.0
+        smallest_subnormal = sys.float_info.min * sys.float_info.epsilon
+        assertEqual(math.nextafter(+0.0, INF), smallest_subnormal)
+        assertEqual(math.nextafter(-0.0, INF), smallest_subnormal)
+        assertEqual(math.nextafter(+0.0, -INF), -smallest_subnormal)
+        assertEqual(math.nextafter(-0.0, -INF), -smallest_subnormal)
+        assertEqualSign(math.nextafter(smallest_subnormal, +0.0), +0.0)
+        assertEqualSign(math.nextafter(-smallest_subnormal, +0.0), -0.0)
+        assertEqualSign(math.nextafter(smallest_subnormal, -0.0), +0.0)
+        assertEqualSign(math.nextafter(-smallest_subnormal, -0.0), -0.0)
+
+        # around infinity
+        largest_normal = sys.float_info.max
+        assertEqual(math.nextafter(INF, 0.0), largest_normal)
+        assertEqual(math.nextafter(-INF, 0.0), -largest_normal)
+        assertEqual(math.nextafter(largest_normal, INF), INF)
+        assertEqual(math.nextafter(-largest_normal, -INF), -INF)
+
+        # NaN
+        assertIsNaN(math.nextafter(NAN, 1.0))
+        assertIsNaN(math.nextafter(1.0, NAN))
+        assertIsNaN(math.nextafter(NAN, NAN))
+
+        assertEqual(1.0, math.nextafter(1.0, INF, steps=0))
+        expect(ValueError):
+            discard math.nextafter(1.0, INF, steps = -1)
+    test_nextafter()
+  test "ulp":
+    const FLOAT_MAX = high float64
+    #@requires_IEEE_754
+    def test_ulp():
+        assertEqual(math.ulp(1.0), sys.float_info.epsilon)
+        # use int ** int rather than float ** int to not rely on pow() accuracy
+        assertEqual(math.ulp(2.0 ** 52), 1.0)
+        assertEqual(math.ulp(2.0 ** 53), 2.0)
+        assertEqual(math.ulp(2.0 ** 64), 4096.0)
+
+        # min and max
+        assertEqual(math.ulp(0.0),
+                         sys.float_info.min * sys.float_info.epsilon)
+        assertEqual(math.ulp(FLOAT_MAX),
+                         FLOAT_MAX - math.nextafter(FLOAT_MAX, -INF))
+
+        # special cases
+        assertEqual(math.ulp(INF), INF)
+        assertIsNaN(math.ulp(math.nan))
+
+        # negative number: ulp(-x) == ulp(x)
+        for x in [0.0, 1.0, 2.0 ** 52, 2.0 ** 64, INF]:
+            #with subTest(x=x):
+                assertEqual(math.ulp(-x), math.ulp(x))
+    test_ulp()
+
 suite "ldexp":
   test "static":
     const f = ldexp(1.0, 2)