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