Floating-point numbers, representation and manipulation

An integer can be stored in a fixed number of bits, but a real number (one with a fractional part, like 3.75 or −0.5) needs a different scheme. 9618 uses floating-point representation:

value = mantissa × 2^exponent

The bit pattern is split into two fields, and both are stored in two's complement:

• The mantissa holds the significant digits as a fraction. The binary point lies just after the sign bit, so the bits after it are worth $\frac{1}{2}, \frac{1}{4}, \frac{1}{8}, \ldots$ The sign bit before the point is worth −1.
• The exponent is a whole number (two's complement) giving the power of 2 — it says how far to move the binary point.

The name "floating-point" comes from the fact that the binary point can float to different positions, set by the exponent — unlike a fixed-point number where the point never moves.

To find the denary value of a stored floating-point number:

1. Read the exponent (two's complement) — it tells you the power of 2.
2. Read the mantissa as a fraction. Add the set fraction bits; if the sign bit is 1, start from −1.
3. Multiply: value = mantissa × 2^exponent.

Example — mantissa 01100000, exponent 0010 (8-bit mantissa, 4-bit exponent):

• Exponent 0010 = +2.
• Mantissa 0.1100000 = $\frac{1}{2} + \frac{1}{4} = 0.75$ (sign bit 0).
• Value = $0.75 \times 2^{2} = 0.75 \times 4 = 3$.

Example with a negative mantissa — 11000000, exponent 0011:

• Sign bit 1 → start at −1; next bit (1/2) is set.
• Mantissa $= -1 + \frac{1}{2} = -0.5$.
• Value $= -0.5 \times 2^{3} = -0.5 \times 8 = -4$.

The sign of the answer must match the mantissa's sign bit — a useful built-in check.

Going the other way:

1. Write the magnitude in binary, including its fractional part. (e.g. 2.5 = 10.1)
2. Move the binary point so the value is in the form 0.xxxx × 2^power (the mantissa as a fraction). Each place you move the point left adds 1 to the exponent.
3. Write the mantissa bits into the field; if the number is negative, take the two's complement of the positive mantissa.
4. Write the exponent in two's complement.
5. Check it is normalised (positive starts 0 1, negative starts 1 0) and verify the value.

Example — store −2.5 (8-bit mantissa, 4-bit exponent):

• 2.5 = $10.1_2$.
• Move the point left 2 places: $10.1 = 0.101 \times 2^{2}$.
• Positive mantissa = 01010000. Negative → flip and add 1: 01010000 → 10101111 → 10110000.
• Exponent +2 = 0010.
• Check: 1.0110000 = $-1 + \frac{1}{4} + \frac{1}{8} = -0.625$; $-0.625 \times 2^{2} = -2.5$ ✓, and it starts 1 0 (normalised negative). ✓

A single real value can be written in many different mantissa/exponent combinations — for example 0.0011 × 2^5 and 0.11 × 2^3 are both equal to 6. Normalisation chooses one standard form by removing wasted leading bits.

Normalised positive number: first two mantissa bits are 0 1. Normalised negative number: first two mantissa bits are 1 0.

How to normalise:

• Positive: shift the mantissa left to remove leading 0s until it starts 0 1.
• Negative: shift the mantissa left to remove leading 1s until it starts 1 0.
• Each left shift multiplies the mantissa by 2, so decrease the exponent by the number of shifts (the value stays the same).

Why normalise?

• Maximum precision — no mantissa bits are wasted on redundant leading 0s/1s, so all of them hold significant digits.
• Unique representation — every value has exactly one normalised form, which makes numbers easier to compare and process.

The total number of bits is fixed, so designers must split them between the mantissa and the exponent. This is a genuine trade-off:

Give more bits to…	You gain…	You lose…
Mantissa	greater precision (more significant digits, smaller rounding errors)	range (fewer exponent bits)
Exponent	greater range (larger and smaller magnitudes)	precision (fewer mantissa bits)

The key links to memorise:

• Mantissa ↔ precision — how accurately a number is stored.
• Exponent ↔ range — how large or small a magnitude can be stored.

Worked comparison — 12 bits total:

• Format A = 8-bit mantissa + 4-bit exponent → fewer magnitudes (small range) but accurate values (good precision).
• Format B = 4-bit mantissa + 8-bit exponent → huge range of magnitudes but coarse values (poor precision).

A scientific application handling astronomical or sub-atomic magnitudes favours more exponent bits; a financial application needing many accurate decimal places favours more mantissa bits.

Because only a finite number of bits is available, floating-point storage is only an approximation of the real numbers. Three problems follow:

Overflow — the magnitude is too large. The exponent needed is bigger than the largest the exponent field can hold, so the number cannot be stored. The result is invalid; a program may raise an error or behave incorrectly.

Underflow — the magnitude is too small (too close to zero). The exponent needed is more negative than the field allows, so the value is typically forced to 0. A small but real quantity is lost, which can make later calculations inaccurate.

Rounding error — many ordinary denary fractions become recurring (non-terminating) binary fractions, which cannot fit in a finite mantissa, so the stored value is an approximation.

Example: convert 0.7 to binary — $0.7 = 0.10110011\overline{0011}\ldots_2$ (it recurs forever). An 8-bit mantissa can only store the bits that fit, giving roughly 0.695, not 0.7. The tiny difference is a rounding error.

Why it matters: small rounding errors accumulate. In a long loop or a large summation, many tiny approximations add up and can produce a noticeably wrong result — which is why careful programs avoid testing floating-point values for exact equality.