Data Representation

A number base is the number of different digits that a number system uses to represent numbers.

The same digits can mean different values in different bases. For example, 100 in binary (base 2), 100 in denary (base 10) and 100 in hexadecimal (base 16) are three different numbers. To show which base is meant, we often write the base as a small number after it, for example 100₂, 100₁₀ and 100₁₆.

In the denary number system (base-10) we use ten digits, 0 to 9. Each digit in a number has a place value, or weight, that is a power of 10. For example, the number 8211 can be broken down like this:

The value of this number is (8 × 10³) + (2 × 10²) + (1 × 10¹) + (1 × 10⁰) = 8,000 + 200 + 10 + 1 = 8,211.

Computers use electronic circuits that work as switches, which can be either on or off. Every type of information in a computer (numbers, text, images, sound, program instructions) is stored and processed using these two states. So computers use a number system with only two digits: 0 for the off state of a switch and 1 for the on state. This is the binary number system, from the Latin word "bini", meaning "two by two" or "pair".

Binary (base-2) follows the same rules as denary, but each digit has a place value that is a power of 2. For example, the binary number 11010110 is represented as:

Its value in denary is (1 × 2⁷) + (1 × 2⁶) + (0 × 2⁵) + (1 × 2⁴) + (0 × 2³) + (1 × 2²) + (1 × 2¹) + (0 × 2⁰) = 128 + 64 + 16 + 4 + 2 = 214.

In binary, the leftmost digit is called the most significant bit (MSB), and the rightmost digit is called the least significant bit (LSB).

The hexadecimal number system (base-16, or hex) uses 16 digits. Denary only has ten symbols (0 to 9), so hexadecimal uses six more, the letters A to F, for the other six digits. The sixteen digits stand for the denary values 0 to 15, and each hex digit is equal to four binary digits:

In hexadecimal each digit has a place value that is a power of 16. For example, the hexadecimal number 7A19 is:

Its value in denary is (7 × 16³) + (10 × 16²) + (1 × 16¹) + (9 × 16⁰) = 28672 + 2560 + 16 + 9 = 31257.

Why hexadecimal is used as a shorthand for binary. Long strings of binary digits are hard for people to read and understand, so programmers often write binary in hexadecimal instead. For example, the colours on a web page are 24-bit codes: 8 bits for a shade of red, 8 for green and 8 for blue. In hexadecimal the same colour needs only 6 digits: orange is FFA500 instead of 111111111010010100000000 in binary.

A binary digit (or bit) is the basic unit of data storage, with a value of 0 or 1. A group of eight bits is called a byte, and a group of four bits is called a nibble.

Storage used to be measured with the decimal prefixes kilo (1,000), mega (1,000,000) and so on, which are powers of 10. Since 1998 there has been a move to special binary prefixes, defined by the International Electrotechnical Commission (IEC), which are powers of 2 and so represent binary values exactly. For example, a kibibyte is 1,024 bytes, whereas a kilobyte is 1,000 bytes.

Look carefully at which letters are capitals:

Here is how many different values a small number of bits can represent:

• One bit can represent 2¹ = 2 different binary patterns: 0 and 1.
• Two bits can represent 2² = 4 different patterns: 00, 01, 10 and 11.
• Three bits can represent 2³ = 8 different patterns: 000, 001, 010, 011, 100, 101, 110 and 111.

With every extra bit, the number of different patterns of 0s and 1s doubles. So n bits can represent 2ⁿ different binary patterns.

For example, 16 bits can represent 2¹⁶ = 65,536 different values.

Each digit of a binary number has a place value that is a power of 2. The place values for an 8-bit number are:

To convert a binary number into denary, add up the place values of only the digits that are 1.

There are two methods for converting a denary number to binary.

Method 1: division by 2

1. Divide the denary number by 2 using division with remainder, and write down the result and the remainder.
2. Keep dividing the result by 2 until you get a result of 0.
3. Write the remainders in reverse order (from the last one to the first) to get the binary number.

Note Division with remainder (also called Euclidean division) gives a whole-number result (the quotient) and a remainder. For example, 7 ÷ 2 gives a result of 3 and a remainder of 1, instead of 3.5. In Python, the floor division operator // gives the whole-number result and the modulo operator % gives the remainder.

Method 2: place values table

1. Draw a table with the place values of each digit.
2. Find the largest place value that fits into the denary number.
3. Set the digit under that place value to 1.
4. Subtract the place value from the denary number.
5. Repeat steps 2 to 4 with what is left, until you reach 0.
6. Set all the other digits to 0.
7. Read the binary number from left to right.

Every four binary digits match one hexadecimal digit, so there is a quick way to convert between them. To convert a binary number to hexadecimal:

1. Working from the right (the LSB), split the binary number into nibbles (groups of four bits). If the last group on the left is short, add 0s at its front.
2. Work out the denary value of each nibble, using the place values 8, 4, 2 and 1.
3. Change each denary value into its hexadecimal digit.
4. Read the hexadecimal number from left to right.

Note To remember the hex digits, learn that 10 is A and 15 is F, and count between them. Or use the table in the hexadecimal section.

To convert a hexadecimal number into binary:

1. Take each hex digit on its own and find its denary value.
2. Convert each denary value into a four-digit binary number, using the place values 8, 4, 2 and 1. Each value must use exactly four digits, so add leading zeros where needed.
3. Read the binary number from left to right.

There are two methods for converting a denary number to hexadecimal.

Method 1: via binary. Convert the denary number into binary, then convert the binary into hexadecimal.

Method 2: division by 16. This works like division by 2 for binary:

1. Divide the denary number by 16 and write down the result and the remainder.
2. Keep dividing the result by 16 until you get a result of 0.
3. Change each remainder into its hexadecimal digit.
4. Write the remainders in reverse order (from the last one to the first).

There are two methods for converting a hexadecimal number to denary.

Method 1: via binary. Convert the hexadecimal number into binary, then convert the binary into denary.

Method 2: place values table.

1. Separate the hex digits and find the denary value of each one.
2. Multiply each value by its hexadecimal place value (1, 16, 256, 4096 and so on).
3. Add the results together.

An unsigned binary number can only be positive (or zero). Every bit, including the most significant bit, is part of the size of the number; no bit says whether the number is positive or negative.

A signed binary number can be positive or negative. In a signed binary number, the first bit (the most significant bit, on the left) is 1 if the number is negative and 0 if it is positive. For example, 10010111 is negative and 01011011 is positive. There are several ways to represent negative numbers; the most common is two’s complement, which is explained below.

Three steps give the smallest value, the largest value and the number of different values that n bits can hold as an unsigned binary integer:

1. The smallest value is 0.
2. The largest value is 2ⁿ – 1, where n is the number of bits.
3. The number of different values is 2ⁿ.

For example, with 2 bits the smallest value is 00 = 0, and the largest value is 11 = 2² – 1 = 4 – 1 = 3. The values go from 0 to 3, which is 2² = 4 different values.

Binary addition uses four rules:

• Rule 1: 0 + 0 = 0
• Rule 2: 0 + 1 = 1, and 1 + 0 = 1
• Rule 3: 1 + 1 = 0 carry 1 (because 1 + 1 = 10 in binary)
• Rule 4: 1 + 1 + 1 = 1 carry 1 (because 1 + 1 + 1 = 11 in binary)

You may be given two or more binary numbers to add. Write them one above the other, lined up on the right. Then work through the columns one at a time, starting from the right (with 8 bits, the 8th bit from the left first, then the 7th). Write each carry in the column to its left, and count it when you apply the rules to that column.

This extra carry is called overflow. It means that the result of adding the two 8-bit numbers is too large to fit in 8 bits: it needs 9. The largest unsigned 8-bit value is 255, and 183 + 199 = 382. If only 8 bits are kept, the stored answer is 01111110 = 126, which is wrong. In the exam, show the overflow bit clearly, to make it clear you know what has happened. You may also be asked what it is and why it happened.

Overflow can also happen with signed numbers. For two’s complement numbers it is shown by the sign of the result: this is explained with the range of two’s complement numbers below.

Whole numbers such as 7, 12 and 3988 are called integers. Unsigned integers are always positive (or zero), while signed integers can be positive or negative. In denary, a negative integer is shown with a minus sign in front, for example –19. In binary there are several ways to represent signed integers; the most common is two’s complement.

Positive numbers. If the denary number is positive, convert it to binary as normal. But its first bit (the MSB) must be 0, to show that it is positive. For example, 23 in binary is 10111. This starts with a 1, which would mean a negative number, so add a 0 at the front: 010111.

Negative numbers. There are several ways to do this; we will use one. Convert the number without its minus sign into binary as normal (with a 0 at the front), then flip every bit (each 1 becomes 0 and each 0 becomes 1), then add binary 1.

Note In the exam you are usually told how many bits to use, for example 8 or 12. Write the positive number with that many bits (adding 0s at the front) before you flip. For example, in 8 bits +100 is 01100100, flipped it is 10011011, and adding 1 gives –100 = 10011100.

One’s complement is another way to represent signed binary integers. A negative number is made by writing the positive number in binary (with a 0 at the front) and then flipping every bit. This is only the first two steps of the two’s complement method: two’s complement is one’s complement plus 1.

As in two’s complement, the first bit is 1 for a negative number. A disadvantage of one’s complement is that it has two patterns for zero: 00000000 (+0) and 11111111 (–0). So 8-bit one’s complement can only hold –127 to +127.

To convert a two’s complement number to denary, first check whether it is positive or negative by looking at the first (leftmost) bit. If it is 1, the number is negative. If it is 0, the number is positive.

If the number is positive, convert it like an ordinary binary number. For example, 01101011 = 64 + 32 + 8 + 2 + 1 = 107.

If it is negative, you need to undo the flipping. The easiest way: working from right to left, copy all the bits up to and including the first 1, then flip all the bits to the left of that 1. Convert the result to denary and put a minus sign in front.

Another method: a negative place value. In two’s complement the leftmost bit has a negative place value. In 8 bits the place values are –128, 64, 32, 16, 8, 4, 2 and 1 (in 12 bits the first is –2048, and in n bits it is –2^n–1). Add up the place values of the bits that are 1, as for any binary number.

Two’s complement numbers cover a different range from unsigned binary numbers with the same number of bits. Unsigned 8 bits can store 0 to 255, while two’s complement 8 bits can store –128 to +127. The number of different values is the same (256), but half of them are now negative.

With n bits in two’s complement:

• the largest (most positive) value is 2^n–1 – 1, a 0 followed by all 1s, for example 01111111 = +127;
• the smallest (most negative) value is –2^n–1, a 1 followed by all 0s, for example 10000000 = –128.

For example, with 6 bits the largest value is 2^6–1 – 1 = 2⁵ – 1 = 32 – 1 = 31, and the smallest is –2⁵ = –32. So the range is –32 to +31.

Overflow in two’s complement. If a result is outside this range, it cannot be stored correctly. When two positive numbers are added, overflow shows as a result that starts with 1, so it looks negative. When two negative numbers are added, it shows as a result that starts with 0. For example, if 01111011 (+123) and 01101000 (+104) are added as two’s complement numbers, the 8-bit result 11100011 reads as –29, because the true answer, 227, is larger than +127. Adding a positive and a negative number can never overflow.

Two’s complement can be used for binary subtraction. Subtracting a number is the same as adding its negative: for example, 12 – 3 is the same as 12 + (–3). So turn the second number into a negative using two’s complement, and then add the two numbers together.

Note Exam questions usually say how many bits to use, for example "perform the subtraction 12 – 127 in 8-bit binary". Write both numbers with that many bits before you start.

Binary coded decimal (BCD) is a way of storing numbers in which each denary digit is stored separately, as its own 4-bit binary code (a nibble). It is useful when single denary digits have to be stored or sent. In the simple scheme used here, the digits 0 to 9 are coded as the binary values 0000 to 1001. The codes 1010 to 1111 have no meaning.

A denary number with more than one digit needs a group of four bits for each digit. There are two ways to store it: one BCD code in each byte, leaving four bits unused, or packed BCD, where two 4-bit codes are stored in one byte. For example, the denary digits 8503 can be stored in either of these ways:

Note A value cannot be BCD if any of its nibbles is 1010 or more, because that is more than 9. For example, 11001101 cannot be BCD: 1100 is 12 and 1101 is 13, which are not single denary digits.

There are several applications where BCD is used. The obvious one is where denary digits have to be displayed, for example on the screen of a calculator or a digital clock: each digit can be sent straight to its own part of the display.

A more surprising application is storing amounts of money. A value such as $300.25 is a fixed-point decimal number (ignoring the dollar sign). You might expect it to be stored as a real number, but real numbers in binary (floating-point) cannot store most decimal fractions exactly. One solution is to store each denary digit as a BCD code, so the value is stored exactly.

Here is how a computer might add currency values stored in BCD. Assume a two-byte packed BCD representation: the first byte holds two denary digits for the whole-number part, and the second byte holds two digits for the fraction part.

Take the values $0.26 and $0.85. The result should be 1 dollar and 11 cents, with a carry from the first decimal place to the whole-number part. But simple binary addition of the BCD codes gives 0010 0110 + 1000 0101 = 1010 1011. The two fraction nibbles now hold the values 10 and 11, but a BCD nibble must be a single digit (0 to 9). This error has also lost the carry to the whole-number part.

The processor has to recognise that an impossible value has been produced and correct it. The solution is to add 0110 (6) to a nibble whenever this problem is found.

• Starting with the least significant nibble, adding 0110 (6) to 0101 (5) gives 1011, which is recognised as wrong.
• The correction value 0110 is added, giving 10001.
• The 0001 is stored and the leading 1 is carried to the next nibble.
• In the first decimal place, adding 0010 (2) to 1000 (8) and then the carry bit 1 gives 1011, which is also recognised as wrong.
• The correction 0110 is added, giving 10001.
• The 0001 is stored and the leading 1 is carried to the next nibble, the whole-number part.
• The two whole-number nibbles were both 0000, so the whole-number part is just the carry: 0000 0001. The result is 0000 0001 . 0001 0001, which is 1 dollar and 11 cents.

To represent text, each character needs its own unique bit pattern. A bit pattern is a combination of 1s and 0s used to represent data inside a computer. The bit pattern used for each character is its numeric character code.

A character can be any of these:

• letters (upper case and lower case letters have different codes)
• punctuation and symbols, such as ? / | \ £ $
• digits (0 to 9)
• non-printing commands, such as Enter, Delete or F1

For computers to exchange text, they must agree which character code stands for which character. A standard collection of characters and the bit patterns used to represent them is called a character set.

ASCII stands for American Standard Code for Information Interchange. It was defined in 1963 and became one of the most common character sets. It uses 7 bits for each character, so it can represent at most 2⁷ = 128 characters.

Today each ASCII character is stored in 8 bits (1 byte). The original codes are unchanged, but each one has a 0 in front, so there are still only 128 bit patterns in the set. The eighth bit was sometimes used as a parity bit to check for errors when data was sent.

When text is stored using ASCII, each character is given a denary character code, which is stored in the computer in binary. The codes follow patterns:

a is 97, b is 98 and c is 99: letters of the alphabet have consecutive codes. So if you know the code of one character, you can work out the codes of the characters before and after it.

Note You do not need to learn any character codes by heart; exam questions give you the codes they use.

Extended ASCII is an extension of the ASCII standard that uses 8 bits for each character. This raises the number of possible characters to 2⁸ = 256. The first 128 codes are the same as standard ASCII; the extra 128 hold characters such as accented letters (for example ü) and symbols.

The problem with ASCII is that it can only represent a small number of characters (128 for standard ASCII). This may be enough for the English alphabet, but not for all the languages and scripts in the world, with all their numbers and symbols. For example, ASCII cannot possibly store the hundreds of thousands of characters in these scripts in just 8 bits:

• Chinese characters 汉字
• Japanese characters 漢字
• Cyrillic Кириллица
• Gujarati ગુજરાતી
• Urdu اردو
• Greek ελληνικά

The spread of the World Wide Web also made a single international code more important, as the range of platforms and programs grew and developers around the world used a much wider range of characters.

The character set most used instead is Unicode. Each Unicode character can be stored using one of three encoding standards, which differ in the smallest number of bits they use:

With over a million possible characters, Unicode can store every character from every alphabet, and many special symbols such as mathematical operators, shapes, arrows, emojis and ideograms. The first 128 codes in Unicode and ASCII represent the same characters.

A number can be stored as a set of characters. For example, the number 35 can be stored as the characters "3" and "5". When a digit (0 to 9) is processed as a character, the computer uses the bit pattern of its character code, not the binary value of the digit.

For example, the number 35 in 8-bit binary is 00100011. But the characters "35" are stored as 00110011 00110101, because in 8-bit ASCII the character code for "3" is 51 = 00110011 and the code for "5" is 53 = 00110101.

So you must be able to tell the difference between the binary value of a denary number and the (different) bit pattern for that number stored as a set of characters.