code: def _get_machar(ftype):
      """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.
      """
      params = _MACHAR_PARAMS.get(ftype)
      if params is None:
          raise ValueError(repr(ftype))
      # Detect known / suspected types
      key = ftype("-0.1").newbyteorder("<").tobytes()
      ma_like = _KNOWN_TYPES.get(key)
      # Could be 80 bit == 10 byte extended precision, where last bytes can be
      # random garbage.  Try comparing first 10 bytes to pattern.
      if ma_like is None and ftype == ntypes.longdouble:
          ma_like = _KNOWN_TYPES.get(key[:10])
      if ma_like is not None:
          return ma_like
      # 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)
  
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 5 for calling a global function with example usage: _get_machar(ftype) and returns: _discovered_machar, ma_like