Thus far in this chapter we have used the binary number system to represent numerical values. It is an efficient code in the sense that each of the $2^{n}$ bit patterns represents a value. On the other hand, there are some limitations in the code. We will explore some other codes in this section.

One limitation of using the binary number system is that a decimal number must be converted to binary before storing or performing arithmetic operations on it. And binary numbers must be converted to decimal for most real-world display purposes.

The Binary Coded Decimal (BCD) code is a code for individual decimal digits. Since there are ten decimal digits, the code must use four bits for each digit. The BCD code is shown in Table 4.5.1.

For example, in a 16-bit storage location the decimal number 1234 would be stored in the BCD code as \begin{gather*} \binary{0001 0010 0011 0100} \end{gather*} and in binary as \begin{gather*} \binary{0000 0100 1101 0010} \end{gather*} From Table 4.5.1 we can see that six bit patterns are “wasted.” The effect of this inefficiency is that a 16-bit storage location has a range of $0$ – $9999$ if we use BCD, but the range is $0$ – $65535$ if we use binary.

BCD is important in specialized systems that deal primarily with numerical data. There are I/O devices that deal directly with numbers in BCD without converting to/from a character code, for example, ASCII. The COBOL programming language supports a packed BCD format where two digits (in BCD code) are stored in each 8-bit byte. The last (4-bit) digit is used to store the sign of the number as shown in Table 4.5.2. The specific codes used depend upon the particular implementation.

For example, $\binary{0001 0010 0011 1010}$ would represent $+123\text{,}$ $\binary{0001 0010 0011 1011}$ would represent $-123\text{,}$ and $\binary{0001 0010 0011 1111}$ would represent $123\text{.}$

One of the problems with both the binary and BCD codes is that the difference between two adjacent values often requires that more than one bit be changed. For example, three bits must be changed when incrementing from $3$ to $4$ ($\binary{0011}$ to $\binary{0100}$). If the value is read during the time when the bits are being switched there may be an error. This is more apt to occur if the bits are implemented with, say, mechanical switches instead of electronic.
The Gray code for four bits is shown in Table 4.5.3. Notice that the pattern of only changing one bit between adjacent values also holds when the bit pattern “wraps around.” That is, only one bit is changed when going from the highest value ($15$ for four bits) to the lowest ($0$).