NF - type_info function with tests

Function to get nmant etc from type.  Works round PPC bug in finfo.

Author: matthew-brett

nibabel/casting.py

@@ -1,6 +1,8 @@
 """ Utilties for casting floats to integers
 """
 
+from platform import processor
+
 import numpy as np
 
 
@@ -165,6 +167,71 @@ class FloatingError(Exception):
     pass
 
 
+def type_info(np_type):
+    """ Return dict with min, max, nexp, nmant, width for numpy type `np_type`
+
+    Type can be integer in which case nexp and nmant are None.
+
+    Parameters
+    ----------
+    np_type : numpy type specifier
+        Any specifier for a numpy dtype
+
+    Returns
+    -------
+    info : dict
+        with fields ``min`` (minimum value), ``max`` (maximum value), ``nexp``
+        (exponent width), ``nmant`` (significand precision not including
+        implicit first digit) ``width`` (width in bytes). ``nexp``, ``nmant``
+        are None for integer types.
+
+    Raises
+    ------
+    FloatingError : for floating point types we don't recognize
+
+    Notes
+    -----
+    You might be thinking that ``np.finfo`` does this job, and it does, except
+    for PPC long doubles (http://projects.scipy.org/numpy/ticket/2077). This
+    routine protects against errors in ``np.finfo`` by only accepting values
+    that we know are likely to be correct.
+    """
+    dt = np.dtype(np_type)
+    width = dt.itemsize
+    try: # integer type
+        info = np.iinfo(dt)
+    except ValueError:
+        pass
+    else:
+        return dict(min=info.min, max=info.max, nmant=None, nexp=None,
+                    width=width)
+    info = np.finfo(dt)
+    vals = info.nmant, info.nexp, width
+    if vals == (10, 5, 2): # binary16
+        assert dt.type is _float16
+    elif vals == (23, 8, 4): # binary32
+        assert dt.type is np.float32
+    elif vals == (23, 8, 8): # binary32, complex
+        assert dt.type is np.complex64
+    elif vals == (52, 11, 8): # binary64
+        assert dt.type in (np.float64, np.longdouble)
+    elif vals == (52, 11, 16): # binary64, complex
+        assert dt.type is np.complex128
+    elif vals == (112, 15, 16): # binary128
+        assert dt.type is np.longdouble
+    elif vals in ((63, 15, 12), (63, 15, 16)): # Intel extended 80
+        assert dt.type is np.longdouble
+    elif vals == (1, 1, 16) and processor() == 'powerpc': # broken PPC
+        assert dt.type is np.longdouble
+        dbl_info = np.finfo(np.float64)
+        return dict(min=dbl_info.min, max=dbl_info.max, nmant=106, nexp=11,
+                    width=width)
+    else: # don't recognize the type
+        raise FloatingError('We had not expected this type')
+    return dict(min=info.min, max=info.max, nmant=info.nmant, nexp=info.nexp,
+               width=width)
+
+
 def flt2nmant(flt_type):
     """ Number of significand bits in float type `flt_type`
 

nibabel/tests/test_floating.py

@@ -3,7 +3,7 @@
 import numpy as np
 
 from ..casting import (floor_exact, flt2nmant, as_int, FloatingError,
-                       int_to_float, floor_log2)
+                       int_to_float, floor_log2, type_info)
 
 from nose import SkipTest
 from nose.tools import assert_equal, assert_raises
@@ -20,6 +20,42 @@
 
 LD_INFO = np.finfo(np.longdouble)
 
+
+def test_type_info():
+    # Test routine to get min, max, nmant, nexp
+    for dtt in np.sctypes['int'] + np.sctypes['uint']:
+        info = np.iinfo(dtt)
+        infod = type_info(dtt)
+        assert_equal(dict(min=info.min, max=info.max, nexp=None, nmant=None,
+                          width=np.dtype(dtt).itemsize), infod)
+    for dtt in IEEE_floats + [np.complex64, np.complex64]:
+        info = np.finfo(dtt)
+        infod = type_info(dtt)
+        assert_equal(dict(min=info.min, max=info.max,
+                          nexp=info.nexp, nmant=info.nmant,
+                          width=np.dtype(dtt).itemsize),
+                     infod)
+    # What is longdouble?
+    info = np.finfo(np.longdouble)
+    dbl_info = np.finfo(np.float64)
+    infod = type_info(np.longdouble)
+    width = np.dtype(np.longdouble).itemsize
+    vals = (info.nmant, info.nexp, width)
+    # Information for PPC head / tail doubles from:
+    # https://developer.apple.com/library/mac/#documentation/Darwin/Reference/Manpages/man3/float.3.html
+    if vals in ((52, 11, 8), # longdouble is same as double
+                (63, 15, 12), (63, 15, 16), # intel 80 bit
+                (112, 15, 16), # real float128
+                (106, 11, 16)): # PPC head, tail doubles, expected values
+        assert_equal(dict(min=info.min, max=info.max,
+                          nexp=info.nexp, nmant=info.nmant, width=width),
+                     infod)
+    elif vals == (1, 1, 16): # bust info for PPC head / tail longdoubles
+        assert_equal(dict(min=dbl_info.min, max=dbl_info.max,
+                          nexp=11, nmant=106, width=16),
+                     infod)
+
+
 def test_flt2nmant():
     for t in IEEE_floats:
         assert_equal(flt2nmant(t), np.finfo(t).nmant)