class_docstr: 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.
code: def __new__(cls, dtype):
      try:
          dtype = numeric.dtype(dtype)
      except TypeError:
          # In case a float instance was given
          dtype = numeric.dtype(type(dtype))
  
      obj = cls._finfo_cache.get(dtype, None)
      if obj is not None:
          return obj
      dtypes = [dtype]
      newdtype = numeric.obj2sctype(dtype)
      if newdtype is not dtype:
          dtypes.append(newdtype)
          dtype = newdtype
      if not issubclass(dtype, numeric.inexact):
          raise ValueError("data type %r not inexact" % (dtype))
      obj = cls._finfo_cache.get(dtype, None)
      if obj is not None:
          return obj
      if not issubclass(dtype, numeric.floating):
          newdtype = _convert_to_float[dtype]
          if newdtype is not dtype:
              dtypes.append(newdtype)
              dtype = newdtype
      obj = cls._finfo_cache.get(dtype, None)
      if obj is not None:
          return obj
      obj = object.__new__(cls)._init(dtype)
      for dt in dtypes:
          cls._finfo_cache[dt] = obj
      return obj
  
imports: from __future__ import division, absolute_import, print_function
  import warnings
  from .machar import MachAr
  from .overrides import set_module
  from .None import numeric
  from .None import numerictypes
  from .numeric import array, inf
  from .umath import log10, exp2
  from .None import umath
label_desc: Use image node_id 1 for calling the finfo obj's underlying member method code with example usage: obj.__new__(cls, dtype) and returns: obj, obj, obj, obj