BCD Converter

BCD is not a way of writing a number in binary. It is a way of writing each decimal digit in binary and keeping the digits separate.

Each digit gets four bits with the ordinary weights 8-4-2-1, so 0 is 0000 and 9 is 1001. Four bits can hold sixteen patterns and only ten digits exist, so six patterns are unused — and that gap is where both the validity rule and the addition correction come from. 59 in packed BCD is 0101 1001, while 59 in plain binary is 00111011: different bits for the same number, which is the whole point.

Encode each digit independently and concatenate: 1234 becomes 0001 0010 0011 0100. No carrying, no division, no dependence between digits — which is exactly why a display driver likes it.

Split into nibbles and read each as a digit: 0x12 0x34 is 1, 2, 3, 4 → 1234. A correct converter validates while it reads, because six of the sixteen nibble values do not name a digit; a decoder that silently accepts them is inventing an answer.

The digits are the same in all four layouts; what differs is how they are laid into bytes.

1010 through 1111 are not digits. Three of them are legal sign nibbles in signed packed BCD, which is why the same byte can be valid or invalid depending on the layout you declared: 12 3C is 123 with a positive sign under signed packed, and an invalid fourth digit under plain packed.

Add the nibbles as ordinary binary. If a nibble sum exceeds 9, or if it produced a carry out of the nibble, add 6 to it and carry 1 into the next digit. 25 + 48: 5 + 8 = 13, which is above 9, so 13 + 6 = 19 → digit 3 with a carry; 2 + 4 + 1 = 7, which needs no correction. The answer is 0111 0011 = 73.

Six is the right correction because four bits count to sixteen and a decimal digit counts to ten: the nibble is running six ahead of the decimal it should be showing, and adding six pushes it past the invalid range and into the carry. The trap is 8 + 8 = 16 = 10000, whose low nibble is 0000 — a perfectly valid-looking 0 — and which is only caught by the carry-out half of the rule.

In hardware the condition is C = C₄ + Q₃Q₂ + Q₃Q₁, feeding a second four-bit adder that adds 0110. That circuit is built from the same full adders as any other ripple.

Subtraction uses 9’s or 10’s complement, exactly as two’s complement does in binary. For 72 − 27: the 9’s complement of 27 is 72, the 10’s complement is 73, and 72 + 73 = 145. The carry out of the most significant digit means the result is positive, so discard it and the answer is 45. With no carry out, the result is negative and is the 10’s complement of the magnitude.

BCD spends about 20% more storage than plain binary for the same range, because four bits carry only 10 of their 16 patterns. In exchange it never has a conversion error, digit extraction for a display is a nibble mask rather than a division, and the precision is unbounded.

BCD has no word width. A 20-digit value is 10 bytes and a 200-digit value is 100 bytes; nothing overflows at 64 bits. 2⁶⁴ − 1 is 18446744073709551615 — twenty digits, and therefore exactly ten packed bytes. The number base converter shows the same value in plain binary for comparison.

• COBOL’s COMP-3 data type is signed packed BCD.
• IBM z/Architecture has packed-decimal instructions in hardware.
• The x86 DAA and AAA instructions exist to apply exactly the +6 correction above.
• Seven-segment display drivers take a BCD nibble per digit.
• DS1307-class real-time-clock chips hold their registers in BCD.

This page implements natural 8421 BCD, and “BCD” unqualified means 8421. Other decimal codes exist and are taught alongside it: Excess-3 adds 3 to each BCD digit, which makes the code self-complementing, and 2421 re-weights the nibble for the same reason. They are named here so that a different answer in your textbook has an explanation rather than being a contradiction.

• Most significant digit first, left to right; nibbles are written most significant bit first.
• Packed BCD holds the more significant digit in the high nibble.
• An odd digit count is left-padded with a zero nibble.
• The sign nibble is the last nibble: 0xC positive, 0xD negative, 0xF unsigned. Hexadecimal is upper case.

8421 BCD is a convention with no single canonical citation and is stated here as a definition. The sign-nibble values are attributed to the IBM and COBOL convention: the same values appear in z/Architecture and in ISO/IEC 1989 without either being their origin, and naming a document as the source would be inventing a provenance.