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
      # ftype(-1.0) / ftype(10.0) is better than ftype('-0.1') because stold
      # may be deficient
      key = ftype(-1.0) / ftype(10.0)
      key = key.view(key.dtype.newbyteorder("<")).tobytes()
      ma_like = None
      if ftype == ntypes.longdouble:
          # Could be 80 bit == 10 byte extended precision, where last bytes can
          # be random garbage.
          # Comparing first 10 bytes to pattern first to avoid branching on the
          # random garbage.
          ma_like = _KNOWN_TYPES.get(key[:10])
      if ma_like is None:
          # see if the full key is known.
          ma_like = _KNOWN_TYPES.get(key)
      if ma_like is None and len(key) == 16:
          # machine limits could be f80 masquerading as np.float128,
          # find all keys with length 16 and make new dict, but make the keys
          # only 10 bytes long, the last bytes can be random garbage
          _kt = {
              k[:10]: v for k, v in _KNOWN_TYPES.items() if len(k) == 16
          }
          ma_like = _kt.get(key[:10])
      if ma_like is not None:
          return ma_like
      # Fall back to parameter discovery
      warnings.warn(
          f"Signature {key} for {ftype} does not match any known type: "
          "falling back to type probe function.\n"
          "This warnings indicates broken support for the dtype!",
          UserWarning,
          stacklevel=2,
      )
      return _discovered_machar(ftype)
  
imports: import warnings
  from .._utils import set_module
  from ._machar import MachAr
  from .None import numeric
  from .None import numerictypes
  from .numeric import array, inf, nan
  from .umath import log10, exp2, nextafter, isnan
label_desc: Use image node_id 5 for calling a global function with example usage: _get_machar(ftype) and returns: _discovered_machar, ma_like