BF - add extra nmant check, simplify tests

Add fallback nmant test when the nmant is stated but we don't know the type.
Simplify tests to use ints instead of numpys default casting to store the
values.  Allow for windows 32 bit case where longdouble is something similar in
precision to float64

Author: matthew-brett

nibabel/casting.py

@@ -164,14 +164,25 @@ def flt2nmant(flt_type):
         return _flt_nmant[flt_type]
     except KeyError:
         pass
-    nmant = np.finfo(flt_type).nmant
+    fi = np.finfo(flt_type)
+    nmant, nexp = fi.nmant, fi.nexp
     # Assuming the np.float type is always IEEE 64 bit
-    if flt_type is np.float and nmant == 52:
+    if flt_type is np.float and (nmant, nexp) == (52, 11):
         return 52
     # Now we should be testing long doubles
     assert flt_type is np.longdouble
-    if nmant == 63: # 80-bit intel type
+    if (nmant, nexp) == (63, 15): # 80-bit intel type
         return 63 # Not including explicit first digit
+    # We test the declared nmant by stepping up and down.  These tests assume a
+    # binary format
+    i_end_contig = 2**(nmant+1) # int
+    f_end_contig = flt_type(i_end_contig)
+    # We need as_int here because long doubles do not necessarily convert
+    # correctly to ints with int() - see
+    # http://projects.scipy.org/numpy/ticket/1395
+    if as_int(f_end_contig-1) == (i_end_contig-1): # still representable
+        if as_int(f_end_contig+1) == i_end_contig: # Rounding down
+            return nmant
     raise FloatingError('Cannot be confident of nmant value for %s' % flt_type)
 
 

nibabel/tests/test_casting.py

@@ -3,7 +3,8 @@
 
 import numpy as np
 
-from ..casting import (float_to_int, int_clippers, CastingError, int_to_float)
+from ..casting import (float_to_int, as_int, int_clippers, CastingError,
+                       int_to_float)
 
 from numpy.testing import (assert_array_almost_equal, assert_array_equal)
 
@@ -80,8 +81,9 @@ def test_casting():
             # We're later going to test if we modify this array
             farr = farr_orig.copy()
             mn, mx = int_clippers(ft, it)
+            imn, imx = as_int(mn), as_int(mx)
             iarr = float_to_int(farr, it)
-            exp_arr = np.array([mn, mx, mn, mx, 0, 0, 11])
+            exp_arr = [imn, imx, imn, imx, 0, 0, 11]
             assert_array_equal(iarr, exp_arr)
             iarr = float_to_int(farr, it, infmax=True)
             # Float16 can overflow to infs
@@ -90,14 +92,9 @@ def test_casting():
             if farr[1] == np.inf:
                 exp_arr[1] = ii.max
             exp_arr[2] = ii.min
-            if exp_arr.dtype.type is np.longdouble:
-                # longdouble seems to go through float64 on assignment; if
-                # ii.max is above float64 integer resolution we have go through
-                # float64 to split up the number and get full precision
-                f64 = np.float64(ii.max)
-                exp_arr[3] = np.longdouble(f64) + np.float64(ii.max - int(f64))
-            else:
-                exp_arr[3] = ii.max
+            exp_arr[3] = ii.max
+            # Always comparing integers here, so no issues with int-float
+            # casting in this comparison
             assert_array_equal(iarr, exp_arr)
             # Confirm input array is not modified
             nans = np.isnan(farr)

nibabel/tests/test_floating.py

@@ -36,8 +36,15 @@ def test_as_int():
     assert_equal(as_int(-2.1, False), -2)
     v = np.longdouble(2**64)
     assert_equal(as_int(v), 2**64)
-    # Have all long doubles got this precision?  We'll see I guess
-    assert_equal(as_int(v+2), 2**64+2)
+    # Have all long doubles got this precision?  Windows 32-bit 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)
+    except FloatingError:
+        nmant = None # Unknown precision, test and hope
+    if nmant is None or nmant >= 63:
+        assert_equal(as_int(v+2), 2**64+2)
 
 
 def test_floor_exact_16():