RF - use type_info for min, max

Replace uses of np.finfo with type_info() function to insulate against
errors in the finfo results for longdouble on PPC.

Author: matthew-brett

nibabel/arraywriters.py

@@ -25,7 +25,7 @@ def __init__(self, array, out_dtype=None)
 
 import numpy as np
 
-from .casting import int_to_float, as_int, int_abs
+from .casting import int_to_float, as_int, int_abs, type_info
 from .volumeutils import finite_range, array_to_file
 
 
@@ -329,13 +329,13 @@ def _range_scale(self):
         """ Calculate scaling based on data range and output type """
         mn, mx = self.finite_range() # These can be floats or integers
         out_dtype = self._out_dtype
+        info = type_info(out_dtype)
+        t_mn_mx = info['min'], info['max']
         if out_dtype.kind == 'f':
-            t_mn_mx = np.finfo(out_dtype).min, np.finfo(out_dtype).max
             # But we want maximum precision for the calculations. Casting will
             # not lose precision because min/max are of fp type.
             t_min, t_max = np.array(t_mn_mx, dtype = np.longdouble)
         else: # (u)int
-            t_mn_mx = np.iinfo(out_dtype).min, np.iinfo(out_dtype).max
             t_min, t_max = [int_to_float(v, np.longdouble) for v in t_mn_mx]
         if self._out_dtype.kind == 'u':
             if mn < 0 and mx > 0:
@@ -484,7 +484,8 @@ def _range_scale(self):
             mn2mx = int_to_float(as_int(mx) - as_int(mn), np.longdouble)
         if out_dtype.kind == 'f':
             # Type range, these are also floats
-            t_mn_mx = np.finfo(out_dtype).min, np.finfo(out_dtype).max
+            info = type_info(out_dtype)
+            t_mn_mx = info['min'], info['max']
         else:
             t_mn_mx = np.iinfo(out_dtype).min, np.iinfo(out_dtype).max
             t_mn_mx= [int_to_float(v, np.longdouble) for v in t_mn_mx]

nibabel/casting.py

@@ -363,14 +363,14 @@ def floor_exact(val, flt_type):
         faval = int_to_float(aval, flt_type)
     except OverflowError:
         faval = np.inf
+    info = type_info(flt_type)
     if faval == np.inf:
-        return sign * np.finfo(flt_type).max
+        return sign * info['max']
     if as_int(faval) <= aval: # as_int deals with longdouble safely
         # Float casting has made the value go down or stay the same
         return sign * faval
     # Float casting made the value go up
-    nmant = type_info(flt_type)['nmant']
-    biggest_gap = 2**(floor_log2(aval) - nmant)
+    biggest_gap = 2**(floor_log2(aval) - info['nmant'])
     assert biggest_gap > 1
     faval -= flt_type(biggest_gap)
     return sign * faval

nibabel/tests/test_arraywriters.py

@@ -37,7 +37,7 @@ def __init__(self, array, out_dtype=None, order='F')
                             WriterError, ScalingError, ArrayWriter,
                             make_array_writer, get_slope_inter)
 
-from ..casting import int_abs
+from ..casting import int_abs, type_info
 
 from ..volumeutils import array_from_file, apply_read_scaling
 
@@ -354,8 +354,8 @@ def test_io_scaling():
                                    (np.float32, np.int16, None)):
         out_dtype = np.dtype(out_type)
         arr = np.zeros((3,), dtype=in_type)
-        info = np.finfo(in_type) if arr.dtype.kind == 'f' else np.iinfo(in_type)
-        arr[0], arr[1] = info.min, info.max
+        info = type_info(in_type)
+        arr[0], arr[1] = info['min'], info['max']
         aw = SlopeInterArrayWriter(arr, out_dtype, calc_scale=False)
         if not err is None:
             assert_raises(err, aw.calc_scale)
@@ -429,17 +429,16 @@ def test_writers_roundtrip():
 
 
 def test_to_float():
+    start, stop = 0, 100
     for in_type in NUMERIC_TYPES:
-        if in_type in IUINT_TYPES:
-            info = np.iinfo(in_type)
-            mn, mx, start, stop, step = info.min, info.max, 0, 100, 1
-        else:
-            info = np.finfo(in_type)
-            mn, mx, start, stop, step = info.min, info.max, 0, 100, 0.5
+        step = 1 if in_type in IUINT_TYPES else 0.5
+        info = type_info(in_type)
+        mn, mx = info['min'], info['max']
         arr = np.arange(start, stop, step, dtype=in_type)
         arr[0] = mn
         arr[-1] = mx
         for out_type in CFLOAT_TYPES:
+            out_info = type_info(out_type)
             for klass in (SlopeInterArrayWriter, SlopeArrayWriter,
                           ArrayWriter):
                 if in_type in COMPLEX_TYPES and out_type in FLOAT_TYPES:
@@ -451,8 +450,7 @@ def test_to_float():
                 arr_back = round_trip(aw)
                 assert_array_equal(arr.astype(out_type), arr_back)
                 # Check too-big values overflowed correctly
-                out_min = np.finfo(out_type).min
-                out_max = np.finfo(out_type).max
+                out_min, out_max = out_info['min'], out_info['max']
                 assert_true(np.all(arr_back[arr > out_max] == np.inf))
                 assert_true(np.all(arr_back[arr < out_min] == -np.inf))
 
@@ -498,8 +496,8 @@ def test_writer_maker():
 def test_float_int_min_max():
     # Conversion between float and int
     for in_dt in FLOAT_TYPES:
-        finf = np.finfo(in_dt)
-        arr = np.array([finf.min, finf.max], dtype=in_dt)
+        finf = type_info(in_dt)
+        arr = np.array([finf['min'], finf['max']], dtype=in_dt)
         for out_dt in IUINT_TYPES:
             try:
                 aw = SlopeInterArrayWriter(arr, out_dt)

nibabel/tests/test_floating.py

@@ -18,7 +18,7 @@
 if have_float16:
     IEEE_floats.append(np.float16)
 
-LD_INFO = np.finfo(np.longdouble)
+LD_INFO = type_info(np.longdouble)
 
 
 def test_type_info():
@@ -63,7 +63,7 @@ def test_type_info():
 def test_nmant():
     for t in IEEE_floats:
         assert_equal(type_info(t)['nmant'], np.finfo(t).nmant)
-    if (LD_INFO.nmant, LD_INFO.nexp) == (63, 15):
+    if (LD_INFO['nmant'], LD_INFO['nexp']) == (63, 15):
         assert_equal(type_info(np.longdouble)['nmant'], 63)
 
 
@@ -87,7 +87,7 @@ def test_as_int():
     v = np.longdouble(2) ** (nmant + 1) - 1
     assert_equal(as_int(v), 2**(nmant + 1) -1)
     # Check for predictable overflow
-    nexp64 = floor_log2(np.finfo(np.float64).max)
+    nexp64 = floor_log2(type_info(np.float64)['max'])
     val = np.longdouble(2**nexp64) * 2 # outside float64 range
     assert_raises(OverflowError, as_int, val)
     assert_raises(OverflowError, as_int, -val)
@@ -103,7 +103,7 @@ def test_int_to_float():
             assert_equal(int_to_float(i, ie3), ie3(i))
             assert_equal(int_to_float(-i, ie3), ie3(-i))
         # IEEEs in this case are binary formats only
-        nexp = floor_log2(np.finfo(ie3).max)
+        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:
@@ -122,7 +122,7 @@ def test_int_to_float():
         assert_equal(int_to_float(i, LD), LD(i))
         assert_equal(int_to_float(-i, LD), LD(-i))
     # Above max of float64, we're hosed
-    nexp64 = floor_log2(np.finfo(np.float64).max)
+    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
@@ -151,7 +151,7 @@ def test_floor_exact_16():
     # A normal integer can generate an inf in float16
     if not have_float16:
         raise SkipTest('No float16')
-    assert_equal(floor_exact(2**31, np.float16), np.finfo(np.float16).max)
+    assert_equal(floor_exact(2**31, np.float16), type_info(np.float16)['max'])
 
 
 def test_floor_exact_64():
@@ -181,8 +181,9 @@ def test_floor_exact():
     int_flex = lambda x, t : as_int(floor_exact(x, t))
     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 = type_info(t)['nmant']
+        info = type_info(t)
+        assert_equal(floor_exact(2**5000, t), info['max'])
+        nmant =  info['nmant']
         for i in range(nmant+1):
             iv = 2**i
             # up to 2**nmant should be exactly representable

nibabel/tests/test_nifti1.py

@@ -14,6 +14,7 @@
 
 import numpy as np
 
+from ..casting import type_info
 from ..tmpdirs import InTemporaryDirectory
 from ..spatialimages import HeaderDataError
 from .. import nifti1 as nifti1
@@ -71,8 +72,8 @@ def test_big_scaling(self):
         sio = BytesIO()
         dtt = np.float32
         # This will generate a huge scalefactor
-        finf = np.finfo(dtt)
-        data = np.array([finf.min, finf.max], dtype=dtt)[:,None, None]
+        finf = type_info(dtt)
+        data = np.array([finf['min'], finf['max']], dtype=dtt)[:,None, None]
         hdr.data_to_fileobj(data, sio)
         data_back = hdr.data_from_fileobj(sio)
         assert_true(np.allclose(data, data_back))
@@ -717,8 +718,8 @@ def test_float_int_min_max():
     # Parallel test to arraywriters
     aff = np.eye(4)
     for in_dt in (np.float32, np.float64):
-        finf = np.finfo(in_dt)
-        arr = np.array([finf.min, finf.max], dtype=in_dt)
+        finf = type_info(in_dt)
+        arr = np.array([finf['min'], finf['max']], dtype=in_dt)
         for out_dt in IUINT_TYPES:
             img = Nifti1Image(arr, aff)
             img_back = round_trip(img)

nibabel/tests/test_scaling.py

@@ -16,6 +16,7 @@
 from ..py3k import BytesIO
 from ..volumeutils import (calculate_scale, scale_min_max, finite_range,
                            apply_read_scaling, array_to_file, array_from_file)
+from ..casting import type_info
 
 from numpy.testing import (assert_array_almost_equal, assert_array_equal)
 
@@ -167,17 +168,6 @@ def test_a2f_nan2zero():
     assert_array_equal(data_back, [np.array(np.nan).astype(np.int32), 99])
 
 
-def type_min_max(dtype_type):
-    # Utility routine to return min, max for dtype dtype
-    if dtype_type in (np.sctypes['complex'] + np.sctypes['float']):
-        info = np.finfo(dtype_type)
-    elif dtype_type in (np.sctypes['int'] + np.sctypes['uint']):
-        info = np.iinfo(dtype_type)
-    else:
-        raise ValueError('Sorry, out of my range')
-    return info.min, info.max
-
-
 def test_array_file_scales():
     # Test scaling works for max, min when going from larger to smaller type,
     # and from float to integer.
@@ -190,7 +180,8 @@ def test_array_file_scales():
                                    (np.float32, np.int16, None)):
         out_dtype = np.dtype(out_type)
         arr = np.zeros((3,), dtype=in_type)
-        arr[0], arr[1] = type_min_max(in_type)
+        info = type_info(in_type)
+        arr[0], arr[1] = info['min'], info['max']
         if not err is None:
             assert_raises(err, calculate_scale, arr, out_dtype, True)
             continue
@@ -229,7 +220,8 @@ def test_scaling_in_abstract():
 def check_int_a2f(in_type, out_type):
     # Check that array to / from file returns roughly the same as input
     big_floater = np.maximum_sctype(np.float)
-    this_min, this_max = type_min_max(in_type)
+    info = type_info(in_type)
+    this_min, this_max = info['min'], info['max']
     if not in_type in np.sctypes['complex']:
         data = np.array([this_min, this_max], in_type)
     else: # Funny behavior with complex256
@@ -255,6 +247,7 @@ def check_int_a2f(in_type, out_type):
     data_back = array_from_file(data.shape, out_type, str_io)
     data_back = apply_read_scaling(data_back, scale32, inter32)
     # Clip at extremes to remove inf
-    out_min, out_max = type_min_max(in_type)
+    info = type_info(in_type)
+    out_min, out_max = info['min'], info['max']
     assert_true(np.allclose(big_floater(data),
                             big_floater(np.clip(data_back, out_min, out_max))))

nibabel/tests/test_spm99analyze.py

@@ -25,6 +25,7 @@
 
 from ..spm99analyze import (Spm99AnalyzeHeader, Spm99AnalyzeImage,
                             HeaderTypeError)
+from ..casting import type_info
 
 from ..testing import (assert_equal, assert_true, assert_false, assert_raises)
 
@@ -62,7 +63,7 @@ def test_big_scaling(self):
         sio = BytesIO()
         dtt = np.float32
         # This will generate a huge scalefactor
-        data = np.array([np.finfo(dtt).max], dtype=dtt)[:,None, None]
+        data = np.array([type_info(dtt)['max']], dtype=dtt)[:,None, None]
         hdr.data_to_fileobj(data, sio)
         data_back = hdr.data_from_fileobj(sio)
         assert_true(np.allclose(data, data_back))

nibabel/tests/test_utils.py

@@ -129,17 +129,17 @@ def test_a2f_intercept_scale():
 
 def test_a2f_upscale():
     # Test working type scales with needed range
-    info = np.finfo(np.float32)
+    info = type_info(np.float32)
     # Test values discovered from stress testing.  The largish value (2**115)
     # overflows to inf after the intercept is subtracted, using float32 as the
     # working precision.  The difference between inf and this value is lost.
-    arr = np.array([[info.min, 2**115, info.max]], dtype=np.float32)
+    arr = np.array([[info['min'], 2**115, info['max']]], dtype=np.float32)
     slope = np.float32(2**121)
-    inter = info.min
+    inter = info['min']
     str_io = BytesIO()
     # We need to provide mn, mx for function to be able to calculate upcasting
     array_to_file(arr, str_io, np.uint8, intercept=inter, divslope=slope,
-                  mn = info.min, mx = info.max)
+                  mn = info['min'], mx = info['max'])
     raw = array_from_file(arr.shape, np.uint8, str_io)
     back = apply_read_scaling(raw, slope, inter)
     top = back - arr
@@ -250,16 +250,16 @@ def test_a2f_zeros():
 
 def test_a2f_big_scalers():
     # Check that clip works even for overflowing scalers / data
-    info = np.finfo(np.float32)
-    arr = np.array([info.min, np.nan, info.max], dtype=np.float32)
+    info = type_info(np.float32)
+    arr = np.array([info['min'], np.nan, info['max']], dtype=np.float32)
     str_io = BytesIO()
     # Intercept causes overflow - does routine scale correctly?
     array_to_file(arr, str_io, np.int8, intercept=np.float32(2**120))
     data_back = array_from_file(arr.shape, np.int8, str_io)
     assert_array_equal(data_back, [-128, 0, 127])
     # Scales also if mx, mn specified?
     str_io.seek(0)
-    array_to_file(arr, str_io, np.int8, mn=info.min, mx=info.max,
+    array_to_file(arr, str_io, np.int8, mn=info['min'], mx=info['max'],
                   intercept=np.float32(2**120))
     data_back = array_from_file(arr.shape, np.int8, str_io)
     assert_array_equal(data_back, [-128, 0, 127])
@@ -270,7 +270,7 @@ def test_a2f_big_scalers():
     assert_array_equal(data_back, [-128, 0, 127])
     # with mn, mx specified?
     str_io.seek(0)
-    array_to_file(arr, str_io, np.int8, mn=info.min, mx=info.max,
+    array_to_file(arr, str_io, np.int8, mn=info['min'], mx=info['max'],
                   divslope=np.float32(0.5))
     data_back = array_from_file(arr.shape, np.int8, str_io)
     assert_array_equal(data_back, [-128, 0, 127])
@@ -302,7 +302,7 @@ def test_apply_scaling():
     ret = apply_read_scaling(np.float32(0), inter=np.float64(2))
     assert_equal(ret.dtype, np.float64)
     # Check integer inf upcast
-    big = f32(np.finfo(f32).max)
+    big = f32(type_info(f32)['max'])
     # 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
@@ -410,8 +410,9 @@ def test_best_write_scale_ftype():
         best_vals += ((np.float64, np.longdouble),)
     for lower_t, higher_t in best_vals:
         # Information on this float
-        t_max = np.finfo(lower_t).max
-        nmant = type_info(lower_t)['nmant'] # number of significand digits
+        L_info = type_info(lower_t)
+        t_max = L_info['max']
+        nmant = L_info['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)

nibabel/volumeutils.py

@@ -16,7 +16,7 @@
 import numpy as np
 
 from .py3k import isfileobj, ZEROB
-from .casting import shared_range
+from .casting import shared_range, type_info
 
 sys_is_le = sys.byteorder == 'little'
 native_code = sys_is_le and '<' or '>'
@@ -908,12 +908,9 @@ def scale_min_max(mn, mx, out_type, allow_intercept):
     '''
     if mn > mx:
         raise ValueError('min value > max value')
-    try:
-        info = np.iinfo(out_type)
-    except ValueError:
-        info = np.finfo(out_type)
+    info = type_info(out_type)
     mn, mx, type_min, type_max = np.array(
-        [mn, mx, info.min, info.max], np.maximum_sctype(np.float))
+        [mn, mx, info['min'], info['max']], np.maximum_sctype(np.float))
     # with intercept
     if allow_intercept:
         data_range = mx-mn