RF - remove flt2mant in favor of type_info

flt2mant too small to be fun to leave in the API

Author: matthew-brett

nibabel/casting.py

@@ -154,14 +154,6 @@ def shared_range(flt_type, int_type):
 except AttributeError: # float16 not present in np < 1.6
     _float16 = None
 
-# The number of significand digits in IEEE floating point formats, not including
-# the implicit leading 0.  See http://en.wikipedia.org/wiki/IEEE_754-2008
-_flt_nmant = {
-    _float16: 10,
-    np.float32: 23,
-    np.float64: 52,
-    }
-
 
 class FloatingError(Exception):
     pass
@@ -234,26 +226,6 @@ def type_info(np_type):
                 nexp=info.nexp, width=width)
 
 
-def flt2nmant(flt_type):
-    """ Number of significand bits in float type `flt_type`
-
-    Parameters
-    ----------
-    flt_type : object
-        Numpy floating point type, such as np.float32
-
-    Returns
-    -------
-    nmant : int
-        Number of digits in the signficand
-    """
-    try:
-        return _flt_nmant[flt_type]
-    except KeyError:
-        pass
-    return type_info(flt_type)['nmant']
-
-
 def as_int(x, check=True):
     """ Return python integer representation of number
 
@@ -398,7 +370,7 @@ def floor_exact(val, flt_type):
         # Float casting has made the value go down or stay the same
         return sign * faval
     # Float casting made the value go up
-    nmant = flt2nmant(flt_type)
+    nmant = type_info(flt_type)['nmant']
     biggest_gap = 2**(floor_log2(aval) - nmant)
     assert biggest_gap > 1
     faval -= flt_type(biggest_gap)

nibabel/tests/test_floating.py

@@ -2,8 +2,8 @@
 """
 import numpy as np
 
-from ..casting import (floor_exact, flt2nmant, as_int, FloatingError,
-                       int_to_float, floor_log2, type_info)
+from ..casting import (floor_exact, as_int, FloatingError, int_to_float,
+                       floor_log2, type_info)
 
 from nose import SkipTest
 from nose.tools import assert_equal, assert_raises
@@ -60,11 +60,11 @@ def test_type_info():
                      infod)
 
 
-def test_flt2nmant():
+def test_nmant():
     for t in IEEE_floats:
-        assert_equal(flt2nmant(t), np.finfo(t).nmant)
+        assert_equal(type_info(t)['nmant'], np.finfo(t).nmant)
     if (LD_INFO.nmant, LD_INFO.nexp) == (63, 15):
-        assert_equal(flt2nmant(np.longdouble), 63)
+        assert_equal(type_info(np.longdouble)['nmant'], 63)
 
 
 def test_as_int():
@@ -81,7 +81,7 @@ def test_as_int():
     # longdouble appears to have 52 bit precision, but we avoid that by checking
     # for known precisions that are less than that required
     try:
-        nmant = flt2nmant(np.longdouble)
+        nmant = type_info(np.longdouble)['nmant']
     except FloatingError:
         nmant = 63 # Unknown precision, let's hope it's at least 63
     v = np.longdouble(2) ** (nmant + 1) - 1
@@ -97,7 +97,7 @@ def test_int_to_float():
     # Concert python integer to floating point
     # Standard float types just return cast value
     for ie3 in IEEE_floats:
-        nmant = flt2nmant(ie3)
+        nmant = type_info(ie3)['nmant']
         for p in range(nmant + 3):
             i = 2**p+1
             assert_equal(int_to_float(i, ie3), ie3(i))
@@ -116,7 +116,8 @@ def test_int_to_float():
     LD = np.longdouble
     # up to integer precision of float64 nmant, we get the same result as for
     # casting directly
-    for p in range(flt2nmant(np.float64)+2): # implicit
+    nmant = type_info(np.float64)['nmant']
+    for p in range(nmant+2): # implicit
         i = 2**p-1
         assert_equal(int_to_float(i, LD), LD(i))
         assert_equal(int_to_float(-i, LD), LD(-i))
@@ -128,7 +129,7 @@ def test_int_to_float():
     assert_raises(OverflowError, int_to_float, smn64, LD)
     assert_raises(OverflowError, int_to_float, smx64, LD)
     try:
-        nmant = flt2nmant(np.longdouble)
+        nmant = type_info(np.longdouble)['nmant']
     except FloatingError: # don't know where to test
         return
     # Assuming nmant is greater than that for float64, test we recover precision
@@ -169,7 +170,7 @@ def test_floor_exact_64():
 def test_floor_exact():
     to_test = IEEE_floats + [float]
     try:
-        flt2nmant(np.longdouble)
+        type_info(np.longdouble)['nmant']
     except FloatingError:
         # Significand bit count not reliable, don't test long double
         pass
@@ -181,7 +182,7 @@ def test_floor_exact():
     for t in to_test:
         # A number bigger than the range returns the max
         assert_equal(floor_exact(2**5000, t), np.finfo(t).max)
-        nmant = flt2nmant(t)
+        nmant = type_info(t)['nmant']
         for i in range(nmant+1):
             iv = 2**i
             # up to 2**nmant should be exactly representable

nibabel/tests/test_utils.py

@@ -34,7 +34,7 @@
                            FLOAT_TYPES,
                            NUMERIC_TYPES)
 
-from ..casting import flt2nmant, FloatingError, floor_log2
+from ..casting import FloatingError, floor_log2, type_info
 
 from numpy.testing import (assert_array_almost_equal,
                            assert_array_equal)
@@ -306,7 +306,8 @@ def test_apply_scaling():
     # Normally this would not upcast
     assert_equal((i16_arr * big).dtype, np.float32)
     # An equivalent case is a little hard to find for the intercept
-    big_delta = np.float32(2**(floor_log2(big)-flt2nmant(np.float32)))
+    nmant_32 = type_info(np.float32)['nmant']
+    big_delta = np.float32(2**(floor_log2(big)-nmant_32))
     assert_equal((i16_arr * big_delta + big).dtype, np.float32)
     # Upcasting does occur with this routine
     assert_equal(apply_read_scaling(i16_arr, big).dtype, np.float64)
@@ -381,9 +382,9 @@ def check_against(f1, f2):
 def have_longer_double():
     # True if longdouble has more precision than float64, and longdouble is
     # something we can rely on
-    nmant_64 = flt2nmant(np.float64) # should be 52
+    nmant_64 = type_info(np.float64)['nmant'] # should be 52
     try:
-        nmant_ld = flt2nmant(np.longdouble)
+        nmant_ld = type_info(np.longdouble)['nmant']
     except FloatingError:
         return False
     return nmant_ld > nmant_64
@@ -410,7 +411,7 @@ def test_best_write_scale_ftype():
     for lower_t, higher_t in best_vals:
         # Information on this float
         t_max = np.finfo(lower_t).max
-        nmant = flt2nmant(lower_t) # number of significand digits
+        nmant = type_info(lower_t)['nmant'] # number of significand digits
         big_delta = lower_t(2**(floor_log2(t_max) - nmant)) # delta below max
         # Even large values that don't overflow don't change output
         arr = np.array([0, t_max], dtype=lower_t)