Convert whole numbers between binary, denary and hexadecimal, and perform binary addition, explaining the role of place value and overflow

What this dot point is asking

SEAB wants you to convert whole numbers fluently between binary (base 2), denary (base 10) and hexadecimal (base 16), to add binary numbers showing carries, and to explain place value and overflow. The central idea is that every base uses the same positional rule - each column is the base raised to a power - so conversion is just a change of which powers you count in.

The answer

Place value in any base

In any base $b$, the digit in the column $i$ places from the right is worth that digit times $b^i$. In binary the columns are powers of two:

So $1011_2 = 8 + 0 + 2 + 1 = 11$. In hexadecimal the columns are powers of sixteen, and the digits run $0$ to $9$ then $\text{A}$ to $\text{F}$ for the values ten to fifteen.

Denary to binary

Two reliable methods:

1. Subtract descending powers of two. Write the place values $128, 64, 32, \dots, 1$. For the number, put a $1$ under the largest power that fits, subtract it, and repeat with the remainder.
2. Repeated division by 2. Divide the number by 2, recording remainders. The remainders read bottom-to-top give the binary digits.

Binary to hexadecimal and back

Because $16 = 2^4$, one hex digit equals exactly four binary bits (a nibble). To go binary to hex, group the bits into nibbles from the right (pad the left with zeros) and convert each nibble. To go hex to binary, expand each hex digit to its four-bit pattern.

binary:  1101 0110
hex:        D    6     -> 0xD6

Binary addition

Add column by column from the right, exactly like denary but carrying whenever a column reaches 2:

0 + 0 = 0
0 + 1 = 1
1 + 1 = 10  (write 0, carry 1)
1 + 1 + 1 = 11  (write 1, carry 1)

Overflow

A fixed-width register can only hold so many bits. If an addition produces a carry out of the most significant bit that there is no column to hold, the result is wrong - this is overflow. For an unsigned $n$-bit number the range is $0$ to $2^n - 1$; a result beyond it overflows.

Examples in context

Example 1. Colour codes on the web. A web colour like #1E90FF is three pairs of hex digits giving the red, green and blue intensities. Each pair is one byte (eight bits), so 1E is $30$, 90 is $144$ and FF is $255$. Reading colours in hex is exactly the nibble-grouping trick applied to bytes.

Example 2. Memory addresses. Debuggers print addresses such as 0x7FFE because hex packs a 16-bit address into four readable digits. An engineer reading 0xFF instantly knows all eight bits of that byte are set, which would be tedious to see in raw binary.

Try this

Q1. Convert $0xB3$ to denary. [2 marks]

• Cue. $\text{B} = 11$ so the high nibble is $11 \times 16 = 176$, and $3$ adds $3$, giving $179$.

Q2. Convert $156$ to 8-bit binary. [2 marks]

• Cue. $156 = 128 + 16 + 8 + 4 = 10011100_2$.

Q3. Add $00111111_2$ and $00000001_2$ and state the result in binary. [2 marks]

• Cue. $63 + 1 = 64 = 01000000_2$; the run of ones rolls over with carries to set the next bit.