RF: Remove old int_to_float() hack

Author: effigies

nibabel/arraywriters.py

@@ -30,7 +30,7 @@ def __init__(self, array, out_dtype=None)
 """
 import numpy as np
 
-from .casting import best_float, floor_exact, int_abs, int_to_float, shared_range, type_info
+from .casting import best_float, floor_exact, int_abs, shared_range, type_info
 from .volumeutils import array_to_file, finite_range
 
 
@@ -418,7 +418,7 @@ def _range_scale(self, in_min, in_max):
             # not lose precision because min/max are of fp type.
             out_min, out_max = np.array((out_min, out_max), dtype=big_float)
         else:  # (u)int
-            out_min, out_max = (int_to_float(v, big_float) for v in (out_min, out_max))
+            out_min, out_max = (big_float(v) for v in (out_min, out_max))
         if self._out_dtype.kind == 'u':
             if in_min < 0 and in_max > 0:
                 raise WriterError(
@@ -584,14 +584,13 @@ def _range_scale(self, in_min, in_max):
             in_min, in_max = np.array([in_min, in_max], dtype=big_float)
             in_range = np.diff([in_min, in_max])
         else:  # max possible (u)int range is 2**64-1 (int64, uint64)
-            # int_to_float covers this range.  On windows longdouble is the
-            # same as double so in_range will be 2**64 - thus overestimating
-            # slope slightly.  Casting to int needed to allow in_max-in_min to
-            # be larger than the largest (u)int value
+            # On windows longdouble is the same as double so in_range will be 2**64 -
+            # thus overestimating slope slightly.  Casting to int needed to allow
+            # in_max-in_min to be larger than the largest (u)int value
             in_min, in_max = int(in_min), int(in_max)
-            in_range = int_to_float(in_max - in_min, big_float)
+            in_range = big_float(in_max - in_min)
             # Cast to float for later processing.
-            in_min, in_max = (int_to_float(v, big_float) for v in (in_min, in_max))
+            in_min, in_max = (big_float(v) for v in (in_min, in_max))
         if out_dtype.kind == 'f':
             # Type range, these are also floats
             info = type_info(out_dtype)

nibabel/casting.py

@@ -445,6 +445,7 @@ def as_int(x, check=True):
     return ix
 
 
+@deprecate_with_version('int_to_float(..., dt) is deprecated. Use dt() instead.', '5.2.0', '7.0.0')
 def int_to_float(val, flt_type):
     """Convert integer `val` to floating point type `flt_type`
 
@@ -467,17 +468,7 @@ def int_to_float(val, flt_type):
     f : numpy scalar
         of type `flt_type`
     """
-    if flt_type is not np.longdouble:
-        return flt_type(val)
-    # The following works around a nasty numpy 1.4.1 bug such that:
-    # >>> int(np.uint32(2**32-1)
-    val = int(val)
-    faval = np.longdouble(0)
-    while val != 0:
-        f64 = np.float64(val)
-        faval += f64
-        val -= int(f64)
-    return faval
+    return flt_type(val)
 
 
 def floor_exact(val, flt_type):
@@ -524,8 +515,8 @@ def floor_exact(val, flt_type):
     val = int(val)
     flt_type = np.dtype(flt_type).type
     sign = 1 if val > 0 else -1
-    try:  # int_to_float deals with longdouble safely
-        fval = int_to_float(val, flt_type)
+    try:
+        fval = flt_type(val)
     except OverflowError:
         return sign * np.inf
     if not np.isfinite(fval):

nibabel/tests/test_casting.py

@@ -14,7 +14,6 @@
     float_to_int,
     floor_log2,
     int_abs,
-    int_to_float,
     longdouble_precision_improved,
     sctypes,
     shared_range,
@@ -41,7 +40,7 @@ def test_shared_range():
             if casted_mx != imax:
                 # The shared_range have told us that they believe the imax does
                 # not have an exact representation.
-                fimax = int_to_float(imax, ft)
+                fimax = ft(imax)
                 if np.isfinite(fimax):
                     assert int(fimax) != imax
                 # Therefore the imax, cast back to float, and to integer, will
@@ -67,7 +66,7 @@ def test_shared_range():
             if casted_mn != imin:
                 # The shared_range have told us that they believe the imin does
                 # not have an exact representation.
-                fimin = int_to_float(imin, ft)
+                fimin = ft(imin)
                 if np.isfinite(fimin):
                     assert int(fimin) != imin
                 # Therefore the imin, cast back to float, and to integer, will

nibabel/tests/test_floating.py

@@ -15,7 +15,6 @@
     floor_exact,
     floor_log2,
     have_binary128,
-    int_to_float,
     longdouble_precision_improved,
     ok_floats,
     on_powerpc,
@@ -127,59 +126,21 @@ def test_check_nmant_nexp():
             assert _check_maxexp(t, ti['maxexp'])
 
 
-def test_int_to_float():
-    # Convert python integer to floating point
-    # Standard float types just return cast value
-    for ie3 in IEEE_floats:
-        nmant = type_info(ie3)['nmant']
-        for p in range(nmant + 3):
-            i = 2**p + 1
-            assert int_to_float(i, ie3) == ie3(i)
-            assert int_to_float(-i, ie3) == ie3(-i)
-        # IEEEs in this case are binary formats only
-        nexp = floor_log2(type_info(ie3)['max'])
-        # Values too large for the format
-        smn, smx = -(2 ** (nexp + 1)), 2 ** (nexp + 1)
-        if ie3 is np.float64:
-            with pytest.raises(OverflowError):
-                int_to_float(smn, ie3)
-            with pytest.raises(OverflowError):
-                int_to_float(smx, ie3)
-        else:
-            assert int_to_float(smn, ie3) == ie3(smn)
-            assert int_to_float(smx, ie3) == ie3(smx)
-    # Longdoubles do better than int, we hope
-    LD = np.longdouble
-    # up to integer precision of float64 nmant, we get the same result as for
-    # casting directly
+def test_int_longdouble_np_regression():
+    # Test longdouble conversion from int works as expected
+    # Previous versions of numpy would fail, and we used a custom int_to_float()
+    # function. This test remains to ensure we don't need to bring it back.
     nmant = type_info(np.float64)['nmant']
-    for p in range(nmant + 2):  # implicit
-        i = 2**p - 1
-        assert int_to_float(i, LD) == LD(i)
-        assert int_to_float(-i, LD) == LD(-i)
-    # Above max of float64, we're hosed
-    nexp64 = floor_log2(type_info(np.float64)['max'])
-    smn64, smx64 = -(2 ** (nexp64 + 1)), 2 ** (nexp64 + 1)
-    # The algorithm here implemented goes through float64, so supermax and
-    # supermin will cause overflow errors
-    with pytest.raises(OverflowError):
-        int_to_float(smn64, LD)
-    with pytest.raises(OverflowError):
-        int_to_float(smx64, LD)
-    try:
-        nmant = type_info(np.longdouble)['nmant']
-    except FloatingError:  # don't know where to test
-        return
     # test we recover precision just above nmant
     i = 2 ** (nmant + 1) - 1
-    assert int(int_to_float(i, LD)) == i
-    assert int(int_to_float(-i, LD)) == -i
+    assert int(np.longdouble(i)) == i
+    assert int(np.longdouble(-i)) == -i
     # If longdouble can cope with 2**64, test
     if nmant >= 63:
         # Check conversion to int; the line below causes an error subtracting
         # ints / uint64 values, at least for Python 3.3 and numpy dev 1.8
         big_int = np.uint64(2**64 - 1)
-        assert int(int_to_float(big_int, LD)) == big_int
+        assert int(np.longdouble(big_int)) == big_int
 
 
 def test_int_np_regression():

nibabel/tests/test_removalschedule.py

@@ -18,6 +18,7 @@
         '8.0.0',
         [
             ('nibabel.casting', 'as_int'),
+            ('nibabel.casting', 'int_to_float'),
             ('nibabel.tmpdirs', 'TemporaryDirectory'),
         ],
     ),