Normalisation of floating-point numbers

The same number can be written in floating point in many ways, just as $0.5 \times 10^{3}$, $0.05 \times 10^{4}$ and $0.005 \times 10^{5}$ are all 500. Normalisation picks one standard form: the one that wastes no mantissa bits. Paper 3 asks you to recognise whether a number is normalised, to normalise it by shifting the mantissa and adjusting the exponent, and to explain why normalisation is done. It builds directly on floating-point numbers.

Many representations of one number

With an 8-bit mantissa and a 4-bit exponent, $0.25$ can be stored as:

Mantissa	Exponent	Value
01000000	1111 ($-1$)	$\tfrac12 \times 2^{-1} = 0.25$
00100000	0000 ($0$)	$\tfrac14 \times 2^{0} = 0.25$
00010000	0001 ($1$)	$\tfrac18 \times 2^{1} = 0.25$
00001000	0010 ($2$)	$\tfrac1{16} \times 2^{2} = 0.25$

Every row is correct, but only the first uses the mantissa well. In the others, the 0s after the sign bit are just copies of the sign; they store no information and take up places that could hold significant bits.

What a normalised number looks like

Put in terms of value, a normalised mantissa $M$ satisfies $\tfrac12 \le M < 1$ if positive and $-1 \le M < -\tfrac12$ if negative.

A mantissa starting 00 or 11 is not normalised: the second bit merely repeats the sign.

Why numbers are normalised

Precision is the reason that matters most. Suppose a calculation produces $0.0001011011_2 \times 2^{0}$ and there is an 8-bit mantissa. Without normalising, the mantissa can only hold 0.0001011, keeping four significant bits (1011) and losing the final 011. Normalised as $0.1011011 \times 2^{-3}$, the mantissa 01011011 keeps all seven significant bits.

How to normalise

The rule is a single trade: moving the mantissa one place left doubles it, so the exponent must go down by 1 to keep the value the same.

A shortcut: count how many places the first 01 or 10 pattern is from the start, shift by that many places at once, and subtract that number from the exponent.

Zero and the special cases

• Zero cannot be normalised: the mantissa 00000000 will never start 01, however far it is shifted. Systems treat a zero mantissa as a special case meaning 0.
• $-1$ is stored as mantissa 10000000, which starts 10, so it is already normalised.
• $-0.5$ looks as though it should be 11000000 with exponent 0, but that starts 11. Normalised, it is 10000000 (that is, $-1$) with exponent 1111 ($-1$): $-1 \times 2^{-1} = -0.5$. The asymmetry exists because two's complement can hold $-1$ but not $+1$.

Normalising in Python

def twos(bits):
    v = int(bits, 2)
    return v - (1 << len(bits)) if bits[0] == "1" else v

def to_bits(value, width):
    if not -(1 << (width - 1)) <= value < (1 << (width - 1)):
        raise OverflowError(f"{value} does not fit in {width} bits")
    return format(value & ((1 << width) - 1), f"0{width}b")

def normalise(mantissa, exponent):
    if set(mantissa) == {"0"}:
        return mantissa, exponent           # zero is a special case
    exp = twos(exponent)
    while mantissa[0] == mantissa[1]:       # first two bits the same
        mantissa = mantissa[1:] + "0"       # shift left
        exp -= 1                            # compensate
    return mantissa, to_bits(exp, len(exponent))

print(normalise("00011010", "0101"))       # ('01101000', '0011')
print(normalise("11100110", "0010"))       # ('10011000', '0000')
print(normalise("00001100", "0001"))       # ('01100000', '1110')
print(normalise("1111001100", "111110"))   # ('1001100000', '111011')
try:
    print(normalise("00000011", "1001"))
except OverflowError as error:
    print("Cannot normalise:", error)      # -12 does not fit in 4 bits

Practice questions

Answers

1. 01011000: normalised (positive, starts 01). 00110000: not normalised (starts 00). 10111000: normalised (negative, starts 10). 11010000: not normalised (starts 11, second bit copies the sign).

2. Shift 1 place: 01011000. Exponent $6 - 1 = 5$ → 0101. Value $0.1011_2 \times 2^{5} = 0.6875 \times 32 = 22$.

3. 11110100 → 11101000 → 11010000 → 10100000: 3 places. Exponent $3 - 3 = 0$ → 0000. Before: $(-1 + \tfrac12 + \tfrac14 + \tfrac18 + \tfrac1{32}) \times 8 = -0.09375 \times 8 = -0.75$. After: $(-1 + \tfrac14) \times 1 = -0.75$. Unchanged.

4. 11101000 → 11010000 → 10100000: 2 places. Exponent 1110 $= -2$; $-2 - 2 = -4$ → 1100. Mantissa 10100000, exponent 1100. Value $-0.75 \times 2^{-4} = -0.046875$.

5. 0001011010 → 0101101000: 2 places. Exponent $7 - 2 = 5$ → 000101. Value $0.101101_2 \times 2^{5} = (0.5 + 0.125 + 0.0625 + 0.015625) \times 32 = 0.703125 \times 32 = 22.5$.

6. Any two of: it gives the maximum precision for the number of bits, because no mantissa bits are wasted on redundant leading 0s or 1s; each number has exactly one representation; it makes comparison and arithmetic of floating-point values consistent and simpler.

7. The exponent 1000 is $-8$, the most negative value a 4-bit exponent can hold. Normalising needs one left shift (00110000 → 01100000), which would make the exponent $-9$, and that cannot be stored. The value is $\tfrac38 \times 2^{-8} = 0.75 \times 2^{-9}$, which is smaller than the smallest positive normalised number in this format, $0.5 \times 2^{-8} = 2^{-9}$. It is too small to be normalised: underflow.

8. Mantissa 10000000 ($-1$), exponent 1111 ($-1$): $-1 \times 2^{-1} = -0.5$. 11000000 with exponent 0 has the value $-0.5$ but starts 11, so it is not normalised: the second bit is a redundant copy of the sign, and one bit of precision is wasted.

9. The true value is $0.0000101101_2 \times 8 = \tfrac{45}{1024} \times 8 = 0.3515625$.

   (a) Unnormalised, the 8-bit mantissa holds only 0.0000101, so the stored value is $\tfrac{5}{128} \times 8 = 0.3125$. Error $= 0.0390625$.

   (b) Normalised: $0.101101_2 \times 2^{-1}$, mantissa 01011010, exponent 1111. Stored value $\tfrac{45}{64} \times \tfrac12 = 0.3515625$. Error $= 0$. All the significant bits fit once the leading zeros are removed.