AQA A-Level Computer Science (7517)

## Learning Outcomes

- Understand what floating-point normalisation means in the AQA two's complement model
- Identify whether a mantissa is normalised by checking its first two bits
- Convert denary values into normalised floating-point binary step by step
- Decode normalised floating-point values back into denary
- Explain why normalisation improves precision and gives a standard representation
- Compare the effect of changing mantissa bits and exponent bits on precision and range
- Recognise when overflow and underflow occur in floating-point systems

## AQA A-Level Computer Science (7517) Syllabus

For the AQA A-Level Computer Science (7517), you are expected to understand floating-point normalisation in binary representation, with a focus on the following syllabus points:

- Know that a floating-point value is stored as a **mantissa × 2^exponent**
- Identify that, in AQA-style questions, both mantissa and exponent are commonly stored in **two’s complement**
- Understand that a normalised two’s complement mantissa has its first two bits different
- Explain why a positive normalised mantissa begins **01** and a negative normalised mantissa begins **10**
- Convert between denary values and normalised floating-point binary using stated mantissa and exponent sizes
- Explain the difference between **range** and **precision**, and how exponent bits and mantissa bits affect each
- Recognise the causes of **overflow** and **underflow** in floating-point representation
- Understand that zero is a special case and cannot be written in strictly normalised form in this simplified model

## Test Your Knowledge

_Attempt these questions before reading this article. If you find some difficult or cannot remember the answers, look more closely at that area during your revision._

1. What rule tells you whether a two’s complement mantissa is normalised?
2. Why does normalisation improve precision?
3. How would you convert a denary value such as 12.75 into normalised floating-point form?
4. What is the difference between increasing mantissa bits and increasing exponent bits?
5. Why can zero not be represented in strictly normalised form in the AQA model?

## Introduction

Floating-point representation is used when fixed point would be too limiting. A fixed binary point gives simple processing, but it struggles when a system must store both very large and very small fractional values. Floating point solves this by storing a number in two parts: a mantissa and an exponent.

For AQA, this topic is often tested through bit-pattern decoding, denary-to-binary conversion, and short explanations about precision, range, overflow, and underflow. The hardest part for many students is that AQA uses a simplified floating-point model in which the mantissa and exponent are often both stored in **two’s complement**. That means normalisation follows a specific rule that is different from what students may have seen elsewhere.

> **Key Term: floating-point representation**
> A method of storing fractional or very large or small numbers using two parts: a mantissa and an exponent, so the binary point can move.

### How floating-point normalisation works

A floating-point value is calculated using this rule:

value = mantissa × 2^exponent

The mantissa stores the significant bits of the number. The exponent tells you how far the binary point should move.

In AQA-style questions, the mantissa is usually a signed binary fraction in **two’s complement**. For an 8-bit mantissa, the place values are:

- **-1**
- **1/2**
- **1/4**
- **1/8**
- **1/16**
- **1/32**
- **1/64**
- **1/128**

The exponent is also usually in two’s complement, but as a signed integer.

> **Key Term: mantissa**
> The part of a floating-point number that stores the significant bits of the value.
>
> **Key Term: exponent**
> The part of a floating-point number that tells the system how far to shift the binary point.

Normalisation means adjusting the mantissa so that the first two bits are different. This removes wasted leading bits and makes best use of the mantissa width.

In the AQA model:

- positive normalised mantissas start **01**
- negative normalised mantissas start **10**
- mantissas starting **00** are not normalised
- mantissas starting **11** are not normalised

Why does this rule work? In two’s complement, positive numbers often begin with several leading 0s, and negative numbers often begin with several leading 1s. Those repeated sign bits do not add useful precision. By shifting the binary point and changing the exponent, we can remove those wasted bits.

For example:

- `00101010` is not normalised because it starts `00`
- `01100100` is normalised because it starts `01`
- `10110000` is normalised because it starts `10`
- `11010110` is not normalised because it starts `11`
  > **Key Term: normalisation**
  > Adjusting a floating-point mantissa into standard form so that, in two’s complement, its first two bits are different.

A good quick check is to look only at the first two bits of the mantissa. If they are opposite, the number is normalised.

> **Test Tip:** In a “state whether this number is normalised” question, do not waste time converting the whole value. Check the first two mantissa bits first.

There are two main reasons examiners expect you to know for normalising:

- it gives a **standard or unique representation** for each non-zero value
- it uses mantissa bits more efficiently, so **precision** is improved

Without normalisation, the same value could be stored in several different ways. That is bad for consistency and wastes mantissa space.

### Converting between floating point and denary

You need to handle two tasks confidently:

- reading a floating-point number and finding its denary value
- writing a denary value as a normalised floating-point number

Start with decoding.

Suppose an 8-bit mantissa and 4-bit exponent are given as:

- Mantissa: `01100100`
- Exponent: `0011`

Step 1: Convert the exponent from two’s complement.

`0011 = +3`

Step 2: Interpret the mantissa as a signed binary fraction.

`01100100` means:

- 0 × -1 = 0
- 1 × 1/2 = 0.5
- 1 × 1/4 = 0.25
- 0 × 1/8 = 0
- 0 × 1/16 = 0
- 1 × 1/32 = 0.03125
- 0 × 1/64 = 0
- 0 × 1/128 = 0

Mantissa value = **0.78125**

Step 3: Apply the exponent.

Value = `0.78125 × 2^3 = 0.78125 × 8 = 6.25`

So the floating-point number represents **6.25**.

Now try a negative example:

- Mantissa: `10110000`
- Exponent: `0010`

The exponent is `+2`.

The mantissa is negative because the first bit is 1. Using the fractional place values:

- 1 × -1 = -1
- 0 × 1/2 = 0
- 1 × 1/4 = 0.25
- 1 × 1/8 = 0.125
- remaining bits are 0

Mantissa value = **-1 + 0.25 + 0.125 = -0.625**

Now apply the exponent:

Value = `-0.625 × 2^2 = -0.625 × 4 = -2.5`

So this pattern represents **-2.5**.

When converting from denary to normalised floating point, the steps must be done in the right order.

Worked example: write **12.75** as an 8-bit mantissa and 4-bit exponent.

Step 1: Convert 12.75 to binary.

- 12 = `1100`
- 0.75 = `0.11`

So `12.75 = 1100.11`

Step 2: Shift the binary point until the mantissa is normalised.

For a positive value, the mantissa must begin `01`.

`1100.11` becomes `0.110011`

The point moved **4 places left**, so the exponent is **+4**.

Step 3: Fit the mantissa to 8 bits.

`0.110011` becomes `01100110`

Step 4: Write the exponent in 4-bit two’s complement.

`+4 = 0100`

Final answer:

- Mantissa: `01100110`
- Exponent: `0100`

Check:

`0.1100110 × 2^4 = 1100.110 = 12.75`

> **Test Tip:** When writing a positive denary number in floating point, first get the ordinary binary value correct. Many mistakes later in the question come from a wrong starting conversion.

A common source of error is negative numbers. A safe method is:

1. convert the positive magnitude to binary
2. normalise it
3. fit it to the required mantissa width
4. convert the mantissa to two’s complement
5. encode the exponent separately

Worked example: write **-3.75** as a 6-bit mantissa and 4-bit exponent.

Step 1: Convert the positive magnitude.

`3.75 = 11.11`

Step 2: Normalise the positive value.

`11.11 = 0.1111 × 2^2`

Step 3: Fit to 6-bit mantissa.

Positive mantissa would be `011110`

Step 4: Convert this mantissa to two’s complement.

Invert: `100001`  
Add 1: `100010`

So the negative mantissa is `100010`

Step 5: Exponent is `+2 = 0010`

Final answer:

- Mantissa: `100010`
- Exponent: `0010`

Students often go wrong by trying to normalise the already-negative bit pattern without thinking about what the positive version should look like first.

Common errors in this topic:

- forgetting the exponent is also in two’s complement
- moving the binary point the wrong way
- changing the exponent in the wrong direction
- checking all bits for normalisation instead of just the first two
- giving a mantissa with the wrong number of bits

### Range, precision, overflow and underflow

Normalisation is closely linked to **range** and **precision**.

> **Key Term: range**
> The spread between the smallest and largest values that a representation can store.
>
> **Key Term: precision**
> How accurately a representation can store values, especially how much rounding is needed.

A fixed total number of bits creates a trade-off.

- more **mantissa bits** gives better precision
- more **exponent bits** gives wider range

Why? The mantissa stores the actual significant detail of the number. Extra mantissa bits mean more fractional places can be kept. The exponent only changes scale, so extra exponent bits let the binary point move further left or right.

Suppose you compare two 12-bit formats:

- Format A: 8-bit mantissa, 4-bit exponent
- Format B: 7-bit mantissa, 5-bit exponent

Format B has one more exponent bit, so it can store much larger and much smaller values. Its range is wider. But it has one fewer mantissa bit, so each stored value is less precise. More rounding may be needed.

That is exactly the sort of explanation AQA likes: not just “range changes” but **why** it changes.

For a two’s complement exponent with **e** bits:

- minimum exponent = `-2^(e-1)`
- maximum exponent = `2^(e-1) - 1`

So with 4 exponent bits, the range is:

- minimum exponent = `-8`
- maximum exponent = `+7`

That tells you how far the binary point can be shifted.

> **Key Term: overflow**
> An error that occurs when a value is too large to be represented in the available format.
>
> **Key Term: underflow**
> An error that occurs when a non-zero value is too small in magnitude to be represented in the available format.

In floating point, overflow usually means the required exponent is too large. Underflow usually means the required exponent is too small, so the value is too close to zero to fit in normalised form.

Example of overflow:

If a format has a maximum exponent of `+7`, but a number needs exponent `+9` after normalisation, it cannot be stored. The number is too large.

Example of underflow:

If a format has a minimum exponent of `-8`, but a tiny non-zero value needs exponent `-10`, it cannot be stored in normalised form. The number is too small.

There is also a special case that students often miss: **zero**.

In the strict AQA normalised model, zero cannot be represented in normalised form. A zero mantissa would be all 0s, so its first two bits would be `00`, not `01` or `10`. That breaks the normalisation rule.

This does not mean computers cannot store zero in practice. It means that, under this simplified exam model, zero is not a **normalised** floating-point value.

> **Key Term: binary point**
> The point in a binary number that separates the whole-number part from the fractional part, like a decimal point in denary.

How to structure an evaluative answer on range and precision:

If a question asks you to explain the effect of changing mantissa and exponent sizes, make sure your answer includes:

- what happens to **range**
- what happens to **precision**
- why the change causes that effect
- whether the new format is better for a particular use

For example, if scientific data needs very large and very small values, more exponent bits may be better. If storing currency or values where exact detail matters more, more mantissa bits may be better.

A strong answer sounds like this: increasing exponent bits allows a wider range because larger positive and negative exponents can be stored, so the binary point can move further. However, reducing mantissa bits lowers precision because fewer significant bits are available. Therefore the better format depends on whether the application needs scale or accuracy.

## Key Point Checklist

_This article has covered the following key knowledge points:_

- AQA floating-point values are commonly stored as **mantissa × 2^exponent**
- In exam questions, both the mantissa and exponent are often stored in **two’s complement**
- A normalised two’s complement mantissa has its first two bits different
- Positive normalised mantissas begin **01** and negative normalised mantissas begin **10**
- Normalisation removes wasted leading sign bits and improves the use of mantissa bits
- Normalisation gives a standard representation for each non-zero value
- To decode a floating-point value, convert the mantissa and exponent separately, then apply the exponent shift
- To encode a denary value, convert to binary, normalise, fit the mantissa width, and encode the exponent
- More mantissa bits mainly improve **precision**
- More exponent bits mainly improve **range**
- **Overflow** happens when the value is too large to fit the format
- **Underflow** happens when a non-zero value is too small to fit in normalised form

## Key Terms and Concepts

- floating-point representation
- mantissa
- exponent
- normalisation
- range
- precision
- overflow
- underflow
- binary point


Data Representation - Floating-point normalisation