BF - work round numpy 1.4.1 int casting bug

In numpy 1.4.1 we have ``int(np.uint32(2**32-1) == -1``. This was
messing up the calculation of the scalefactor.  Thanks to Yarik for
finding the test failure in test_scaling_in_abstract.

Author: matthew-brett

nibabel/arraywriters.py

@@ -23,7 +23,7 @@ def __init__(self, array, out_dtype=None)
 
 import numpy as np
 
-from .casting import shared_range, int_to_float
+from .casting import shared_range, int_to_float, as_int
 from .volumeutils import finite_range, array_to_file
 
 
@@ -442,8 +442,9 @@ def _range_scale(self):
         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 mn2mx will be 2**64 - thus overestimating slope
-            # slightly.  Casting to int here is probably not necessary
-            mn2mx = int_to_float(int(mx) - int(mn), np.longdouble)
+            # slightly.  Casting to int needed to allow mx-mn to be larger than
+            # the largest (u)int value
+            mn2mx = int_to_float(as_int(mx) - as_int(mn), np.longdouble)
         slope = mn2mx / scaled_mn2mx
         self.inter = mn - shared_min * slope
         self.slope = slope

nibabel/casting.py

@@ -210,13 +210,16 @@ def as_int(x, check=True):
     This is useful because the numpy int(val) mechanism is broken for large
     values in np.longdouble.
 
+    It is also useful to work around a numpy 1.4.1 bug in conversion of uints to
+    python ints.
+
     This routine will still raise an OverflowError for values that are outside
     the range of float64.
 
     Parameters
     ----------
     x : object
-        Floating point value
+        integer, unsigned integer or floating point value
     check : {True, False}
         If True, raise error for values that are not integers
 
@@ -238,7 +241,15 @@ def as_int(x, check=True):
     >>> as_int(2.1, check=False)
     2
     """
-    x = np.array(x, copy=True)
+    x = np.array(x)
+    if x.dtype.kind in 'iu':
+        # This works around a nasty numpy 1.4.1 bug such that:
+        # >>> int(np.uint32(2**32-1)
+        # -1
+        return int(str(x))
+    ix = int(x)
+    if ix == x:
+        return ix
     fx = np.floor(x)
     if check and fx != x:
         raise FloatingError('Not an integer: %s' % x)

nibabel/tests/test_floating.py

@@ -97,6 +97,15 @@ def test_int_to_float():
     assert_equal(as_int(int_to_float(-i, LD)), -i)
 
 
+def test_as_int_np_fix():
+    # Test as_int works for integers.  We need as_int for integers because of a
+    # numpy 1.4.1 bug such that int(np.uint32(2**32-1) == -1
+    for t in np.sctypes['int'] + np.sctypes['uint']:
+        info = np.iinfo(t)
+        mn, mx = np.array([info.min, info.max], dtype=t)
+        assert_equal((mn, mx), (as_int(mn), as_int(mx)))
+
+
 def test_floor_exact_16():
     # A normal integer can generate an inf in float16
     if not have_float16: