Floating-point numbers

Integers in two's complement cannot hold 6.5 or 0.0001, and a fixed binary point cannot hold both very large and very small numbers. Floating-point representation solves this by storing a number as a mantissa (the significant digits) and an exponent (how far to move the binary point), exactly like scientific notation in denary. Floating-point conversion is one of the most reliably examined skills in Paper 3: you will convert in both directions, usually with an 8-, 10- or 12-bit mantissa and a 4- to 8-bit exponent, without a calculator, and explain how the split of bits affects range and precision.

The idea: scientific notation in binary

In denary, $6\,370\,000 = 0.637 \times 10^{7}$. The digits $0.637$ carry the precision; the power $7$ carries the size. Binary works the same way with powers of 2:

$$110.1_2 = 0.1101_2 \times 2^{3}$$

Move the binary point three places left and record "3" to say how to put it back.

The Cambridge format

In the format Cambridge uses:

• The mantissa is in two's complement, with the binary point between the first and second bits. The first bit therefore has place value $-1$, and the following bits are $\tfrac12, \tfrac14, \tfrac18, \dots$
• The exponent is a two's complement integer.
• The number of bits in each is given in the question, for example "an 8-bit mantissa followed by a 4-bit exponent".

So the first bit of the mantissa is the sign: 0 for a positive number, 1 for a negative one. The first bit of the exponent is its sign too: a negative exponent moves the point to the left and makes the number smaller in size.

Converting floating-point binary to denary

There are two reliable ways. Use whichever you make fewer mistakes with, and check with the other.

Converting denary to floating-point binary

This method produces a normalised number (one that starts 01 or 10), which is what questions almost always want. Why that matters is covered in normalisation.

Range and precision: how the bits are shared

A fixed total number of bits must be split between mantissa and exponent, and the split is a trade-off.

The reason: every extra mantissa bit halves the gap between neighbouring representable values; every extra exponent bit roughly squares the largest power of 2 available.

The extremes for a given format

For a normalised number with an 8-bit mantissa and a 4-bit exponent:

Quantity	Mantissa	Exponent	Value
Largest positive	01111111 ($\tfrac{127}{128}$)	0111 ($7$)	$\tfrac{127}{128} \times 2^{7} = 127$
Smallest positive (normalised)	01000000 ($\tfrac12$)	1000 ($-8$)	$\tfrac12 \times 2^{-8} = 2^{-9} = 0.001953125$
Most negative	10000000 ($-1$)	0111 ($7$)	$-1 \times 2^{7} = -128$

Compare a 12-bit total split as 6-bit mantissa and 6-bit exponent. The exponent now goes up to $31$, so the largest positive value is $\tfrac{31}{32} \times 2^{31} \approx 2.08 \times 10^{9}$, far larger than 127; but the mantissa has only 5 bits after the point, so only about 5 significant bits of any number are kept.

A converter in Python

Python's float uses the IEEE 754 standard, which is not the Cambridge format, so you cannot inspect its bits to check answers. These functions implement the Cambridge format exactly and are a good way to check your own conversions when revising.

from fractions import Fraction

def twos_complement_value(bits):
    """Integer value of a two's complement bit string."""
    value = int(bits, 2)
    if bits[0] == "1":
        value -= 1 << len(bits)
    return value

def float_to_denary(mantissa, exponent):
    """Mantissa has its binary point after the first bit."""
    m = Fraction(twos_complement_value(mantissa), 1 << (len(mantissa) - 1))
    e = twos_complement_value(exponent)
    return m * Fraction(2) ** e

def to_bits(value, width):
    """Two's complement bit string of an integer."""
    return format(value & ((1 << width) - 1), f"0{width}b")

def denary_to_float(x, m_bits, e_bits):
    """Normalised representation, truncating any bits that do not fit."""
    x = Fraction(x)
    for e in range(-(1 << (e_bits - 1)), 1 << (e_bits - 1)):
        m = x / Fraction(2) ** e
        if Fraction(1, 2) <= m < 1 or -1 <= m < Fraction(-1, 2):
            scaled = m * (1 << (m_bits - 1))
            whole = scaled.numerator // scaled.denominator
            return to_bits(whole, m_bits), to_bits(e, e_bits)
    raise OverflowError("cannot be represented")

print(float(float_to_denary("01011000", "0011")))   # 5.5
print(float(float_to_denary("10100000", "0010")))   # -3.0
print(float(float_to_denary("01100000", "1110")))   # 0.1875
print(denary_to_float("12.75", 8, 4))               # ('01100110', '0100')
print(denary_to_float("-6.5", 8, 4))                # ('10011000', '0011')
print(denary_to_float("0.15625", 8, 4))             # ('01010000', '1110')
print(denary_to_float("-19.375", 12, 4))            # ('101100101000', '0101')

Practice questions

Answers

1. (a) Exponent $3$. Mantissa 0.110100000 $= \tfrac12 + \tfrac14 + \tfrac1{16} = 0.8125$. Value $0.8125 \times 8 = 6.5$.

   (b) Exponent $4$. Mantissa 1.011000000 $= -1 + \tfrac14 + \tfrac18 = -0.625$. Value $-0.625 \times 16 = -10$.

   (c) Exponent 111101 $= -32 + 16 + 8 + 4 + 1 = -3$. Mantissa 0.101000000 $= 0.625$. Value $0.625 \times 2^{-3} = 0.078125$.

2. $27.25 = 11011.01_2 = 0.1101101 \times 2^{5}$. Mantissa 01101101, exponent 0101. Check: $0.1101101_2 = \tfrac{109}{128}$; $\tfrac{109}{128} \times 32 = 27.25$.

3. $10.25 = 1010.01_2 = 0.101001 \times 2^{4}$. Positive mantissa 01010010; two's complement 10101110. Exponent 0100. Check: $-1 + \tfrac14 + \tfrac1{16} + \tfrac1{32} + \tfrac1{64} = -0.640625$; $\times 16 = -10.25$.

4. $0.0234375 = \tfrac{3}{128} = 0.0000011_2 = 0.11 \times 2^{-5}$. Mantissa 01100000. Exponent $-5$: $5 = 0101$, two's complement 1011. Check: $0.75 \times 2^{-5} = 0.0234375$.

5. $0.0390625 = \tfrac{5}{128} = 0.0000101_2 = 0.101 \times 2^{-4}$. Positive mantissa 010100000000; two's complement 101100000000. Exponent $-4$: 1100. Check: $(-1 + \tfrac14 + \tfrac18) \times 2^{-4} = -0.625 \div 16 = -0.0390625$.

6. (a) Mantissa 01111111, exponent 0111: $\tfrac{127}{128} \times 2^{7} = 127$. (b) Mantissa 10000000, exponent 0111: $-1 \times 2^{7} = -128$. (c) Mantissa 01000000, exponent 1000: $\tfrac12 \times 2^{-8} = 2^{-9} = 0.001953125$.

7. The 8-bit mantissa and 8-bit exponent. The exponent then ranges from $-128$ to $127$, so magnitudes up to about $2^{127}$ can be stored, which is needed for very large astronomical distances; a 4-bit exponent only reaches $2^{7}$, so these values would overflow. An 8-bit mantissa (7 bits after the point) gives precision of roughly 1 part in 128, about two significant denary figures, which is all the scientist needs. The trade-off of less precision for more range is therefore the right one.

8. Exponent 0011 $= 3$. Mantissa 1.01101110000 $= -1 + \tfrac14 + \tfrac18 + \tfrac1{32} + \tfrac1{64} + \tfrac1{128} = -1 + 0.4296875 = -0.5703125$. Value $= -0.5703125 \times 8 = -4.5625$. (Moving the point 3 places right gives 1011.01110000; place values $-8 + 2 + 1 + \tfrac14 + \tfrac18 + \tfrac1{16} = -4.5625$.)