"""Machine limits for Float32 and Float64 and (long double) if available...
"""
"""fix rank-0 --> rank-1"""
"""fix rank > 0 --> rank-0"""
""" Object to simulate MachAr instance """
ftype, **kwargs):
# Parameter types same as for discovered MachAr object.
ntypes.csingle: ntypes.single, ntypes.complex_: ntypes.float_, ntypes.clongfloat: ntypes.longfloat }
# Parameters for creating MachAr / MachAr-like objects ntypes.double: dict( itype = ntypes.int64, fmt = '%24.16e', title = _title_fmt.format('double')), ntypes.single: dict( itype = ntypes.int32, fmt = '%15.7e', title = _title_fmt.format('single')), ntypes.longdouble: dict( itype = ntypes.longlong, fmt = '%s', title = _title_fmt.format('long double')), ntypes.half: dict( itype = ntypes.int16, fmt = '%12.5e', title = _title_fmt.format('half'))}
# Key to identify the floating point type. Key is result of # ftype('-0.1').newbyteorder('<').tobytes() # See: # https://perl5.git.perl.org/perl.git/blob/3118d7d684b56cbeb702af874f4326683c45f045:/Configure
# Known parameters for float16 # See docstring of MachAr class for description of parameters. machep=-10, negep=-11, minexp=-14, maxexp=16, it=10, iexp=5, ibeta=2, irnd=5, ngrd=0, eps=exp2(f16(-10)), epsneg=exp2(f16(-11)), huge=f16(65504), tiny=f16(2 ** -14))
# Known parameters for float32 machep=-23, negep=-24, minexp=-126, maxexp=128, it=23, iexp=8, ibeta=2, irnd=5, ngrd=0, eps=exp2(f32(-23)), epsneg=exp2(f32(-24)), huge=f32((1 - 2 ** -24) * 2**128), tiny=exp2(f32(-126)))
# Known parameters for float64 machep=-52, negep=-53, minexp=-1022, maxexp=1024, it=52, iexp=11, ibeta=2, irnd=5, ngrd=0, eps=2.0 ** -52.0, epsneg=epsneg_f64, huge=(1.0 - epsneg_f64) / tiny_f64 * f64(4), tiny=tiny_f64)
# Known parameters for IEEE 754 128-bit binary float # Ignore runtime error when this is not f128 machep=-112, negep=-113, minexp=-16382, maxexp=16384, it=112, iexp=15, ibeta=2, irnd=5, ngrd=0, eps=exp2(ld(-112)), epsneg=epsneg_f128, huge=huge_f128, tiny=tiny_f128) # IEEE 754 128-bit binary float b'\x9a\x99\x99\x99\x99\x99\x99\x99\x99\x99\x99\x99\x99\x99\xfb\xbf') b'\x9a\x99\x99\x99\x99\x99\x99\x99\x99\x99\x99\x99\x99\x99\xfb\xbf')
# Known parameters for float80 (Intel 80-bit extended precision) # Ignore runtime error when this is not f80 machep=-63, negep=-64, minexp=-16382, maxexp=16384, it=63, iexp=15, ibeta=2, irnd=5, ngrd=0, eps=exp2(ld(-63)), epsneg=epsneg_f80, huge=huge_f80, tiny=tiny_f80) # float80, first 10 bytes containing actual storage
# Guessed / known parameters for double double; see: # https://en.wikipedia.org/wiki/Quadruple-precision_floating-point_format#Double-double_arithmetic # These numbers have the same exponent range as float64, but extended number of # digits in the significand. if hasattr(umath, 'nextafter') # Missing on some platforms? else float64_ma.huge) machep=-105, negep=-106, minexp=-1022, maxexp=1024, it=105, iexp=11, ibeta=2, irnd=5, ngrd=0, eps=exp2(ld(-105)), epsneg= exp2(ld(-106)), huge=huge_dd, tiny=exp2(ld(-1022))) # double double; low, high order (e.g. PPC 64) b'\x9a\x99\x99\x99\x99\x99Y<\x9a\x99\x99\x99\x99\x99\xb9\xbf') # double double; high, low order (e.g. PPC 64 le) b'\x9a\x99\x99\x99\x99\x99\xb9\xbf\x9a\x99\x99\x99\x99\x99Y<')
""" Get MachAr instance or MachAr-like instance
Get parameters for floating point type, by first trying signatures of various known floating point types, then, if none match, attempting to identify parameters by analysis.
Parameters ---------- ftype : class Numpy floating point type class (e.g. ``np.float64``)
Returns ------- ma_like : instance of :class:`MachAr` or :class:`MachArLike` Object giving floating point parameters for `ftype`.
Warns ----- UserWarning If the binary signature of the float type is not in the dictionary of known float types. """ raise ValueError(repr(ftype)) # Detect known / suspected types # Could be 80 bit == 10 byte extended precision, where last bytes can be # random garbage. Try comparing first 10 bytes to pattern. ma_like = _KNOWN_TYPES.get(key[:10]) # Fall back to parameter discovery warnings.warn( 'Signature {} for {} does not match any known type: ' 'falling back to type probe function'.format(key, ftype), UserWarning, stacklevel=2) return _discovered_machar(ftype)
""" Create MachAr instance with found information on float types """ params = _MACHAR_PARAMS[ftype] return MachAr(lambda v: array([v], ftype), lambda v:_fr0(v.astype(params['itype']))[0], lambda v:array(_fr0(v)[0], ftype), lambda v: params['fmt'] % array(_fr0(v)[0], ftype), params['title'])
""" finfo(dtype)
Machine limits for floating point types.
Attributes ---------- bits : int The number of bits occupied by the type. eps : float The smallest representable positive number such that ``1.0 + eps != 1.0``. Type of `eps` is an appropriate floating point type. epsneg : floating point number of the appropriate type The smallest representable positive number such that ``1.0 - epsneg != 1.0``. iexp : int The number of bits in the exponent portion of the floating point representation. machar : MachAr The object which calculated these parameters and holds more detailed information. machep : int The exponent that yields `eps`. max : floating point number of the appropriate type The largest representable number. maxexp : int The smallest positive power of the base (2) that causes overflow. min : floating point number of the appropriate type The smallest representable number, typically ``-max``. minexp : int The most negative power of the base (2) consistent with there being no leading 0's in the mantissa. negep : int The exponent that yields `epsneg`. nexp : int The number of bits in the exponent including its sign and bias. nmant : int The number of bits in the mantissa. precision : int The approximate number of decimal digits to which this kind of float is precise. resolution : floating point number of the appropriate type The approximate decimal resolution of this type, i.e., ``10**-precision``. tiny : float The smallest positive usable number. Type of `tiny` is an appropriate floating point type.
Parameters ---------- dtype : float, dtype, or instance Kind of floating point data-type about which to get information.
See Also -------- MachAr : The implementation of the tests that produce this information. iinfo : The equivalent for integer data types.
Notes ----- For developers of NumPy: do not instantiate this at the module level. The initial calculation of these parameters is expensive and negatively impacts import times. These objects are cached, so calling ``finfo()`` repeatedly inside your functions is not a problem.
"""
except TypeError: # In case a float instance was given dtype = numeric.dtype(type(dtype))
raise ValueError("data type %r not inexact" % (dtype)) return obj newdtype = _convert_to_float[dtype] if newdtype is not dtype: dtypes.append(newdtype) dtype = newdtype return obj
'maxexp', 'minexp', 'negep', 'machep']:
def __str__(self): fmt = ( 'Machine parameters for %(dtype)s\n' '---------------------------------------------------------------\n' 'precision = %(precision)3s resolution = %(_str_resolution)s\n' 'machep = %(machep)6s eps = %(_str_eps)s\n' 'negep = %(negep)6s epsneg = %(_str_epsneg)s\n' 'minexp = %(minexp)6s tiny = %(_str_tiny)s\n' 'maxexp = %(maxexp)6s max = %(_str_max)s\n' 'nexp = %(nexp)6s min = -max\n' '---------------------------------------------------------------\n' ) return fmt % self.__dict__
def __repr__(self): c = self.__class__.__name__ d = self.__dict__.copy() d['klass'] = c return (("%(klass)s(resolution=%(resolution)s, min=-%(_str_max)s," " max=%(_str_max)s, dtype=%(dtype)s)") % d)
""" iinfo(type)
Machine limits for integer types.
Attributes ---------- bits : int The number of bits occupied by the type. min : int The smallest integer expressible by the type. max : int The largest integer expressible by the type.
Parameters ---------- int_type : integer type, dtype, or instance The kind of integer data type to get information about.
See Also -------- finfo : The equivalent for floating point data types.
Examples -------- With types:
>>> ii16 = np.iinfo(np.int16) >>> ii16.min -32768 >>> ii16.max 32767 >>> ii32 = np.iinfo(np.int32) >>> ii32.min -2147483648 >>> ii32.max 2147483647
With instances:
>>> ii32 = np.iinfo(np.int32(10)) >>> ii32.min -2147483648 >>> ii32.max 2147483647
"""
except TypeError: self.dtype = numeric.dtype(type(int_type)) raise ValueError("Invalid integer data type %r." % (self.kind,))
"""Minimum value of given dtype.""" return 0 else:
"""Maximum value of given dtype.""" val = int((1 << self.bits) - 1) else:
def __str__(self): """String representation.""" fmt = ( 'Machine parameters for %(dtype)s\n' '---------------------------------------------------------------\n' 'min = %(min)s\n' 'max = %(max)s\n' '---------------------------------------------------------------\n' ) return fmt % {'dtype': self.dtype, 'min': self.min, 'max': self.max}
def __repr__(self): return "%s(min=%s, max=%s, dtype=%s)" % (self.__class__.__name__, self.min, self.max, self.dtype)
|