docs: def fix_to_float(signed, n_bits, n_frac):
      """**DEPRECATED** Return a function to convert a fixed point value to a
      floating point value.
  
      .. warning::
          This function is deprecated in favour of :py:meth:`~.fp_to_float`.
  
      For example, a function to convert from signed fractional representations
      with 8 bits overall and 4 fractional representations (S3.4) can be
      constructed and used with::
  
          >>> f = fix_to_float(True, 8, 4)
          >>> f(0x08)
          0.5
  
          >>> f(0xf8)
          -0.5
  
          >>> f(0x88)
          -7.5
  
      Parameters
      ----------
      signed : bool
          Determines whether input values should be treated as signed or
          otherwise, e.g.::
  
              >>> fix_to_float(True, 8, 4)(0xfc)
              -0.25
  
              >>> fix_to_float(False, 8, 4)(0xf8)
              15.5
  
          The value accepted by the returned function should always be an
          unsigned integer.
      n_bits : int
          Total number of bits in the fixed-point representation (including sign
          bit and fractional bits).
      n_frac : int
          Number of fractional bits in the fixed-point representation.
  
      Raises
      ------
      ValueError
          If the number of bits specified is not possible.  For example,
          requiring more fractional bits than there are bits overall will result
          in a `ValueError`::
  
              >>> fix_to_float(False, 8, 9)
              Traceback (most recent call last):
              ValueError: n_frac: 9: Must be less than 8 (and positive).
      """
      warnings.warn("fix_to_float() is deprecated, see fp_to_float",
                    DeprecationWarning)
  
      validate_fp_params(signed, n_bits, n_frac)
  
      def kbits(value):
          """Convert a fixed point value to a float.
  
          Parameters
          ----------
          value : int
              The fix point value as an integer.
          """
          if signed and value & (1 << (n_bits - 1)):
              # If signed and negative
              value -= (1 << n_bits)
  
          # Unsigned or signed and positive
          return float(value) / (2.0**n_frac)
  
      return kbits