BINARY-CODED DECIMAL

From Wikipedia, the free encyclopedia

"BCD code" redirects here. For BCD character sets, see BCD (character encoding).

A binary clock might use LEDs to express binary values. In this clock, each column of LEDs
shows a binary-coded decimal numeral of the traditional sexagesimal time.
In computing and electronic systems, binary-coded decimal (BCD) is a class of binary
encodings of decimal numbers where each decimal digit is represented by a fixed number of
bits, usually four or eight. Special bit patterns are sometimes used for a sign or for other
indications (e.g., error or overflow).

In byte-oriented systems (i.e. most modern computers), the term unpacked BCD[1] usually
implies a full byte for each digit (often including a sign), whereas packed BCD typically
encodes two decimal digits within a single byte by taking advantage of the fact that four bits
are enough to represent the range 0 to 9. The precise 4-bit encoding may vary however, for
technical reasons, see Excess-3 for instance. The ten states representing a BCD decimal digit
are sometimes called tetrades (for the nibble typically needed to hold them also known as
tetrade) with those don't care-states unused named pseudo-tetrad(e)s (de)[2][3][4][5] or
pseudo-decimal digit[6]).[nb 1]

BCD's main virtue is its more accurate representation and rounding of decimal quantities as
well as an ease of conversion into human-readable representations, in comparison to binary
positional systems. BCD's principal drawbacks are a small increase in the complexity of the
circuits needed to implement basic arithmetics and a slightly less dense storage.

BCD was used in many early decimal computers, and is implemented in the instruction set of
machines such as the IBM System/360 series and its descendants and Digital's VAX.
Although BCD per se is not as widely used as in the past and is no longer implemented in
computers' instruction sets[dubious discuss], decimal fixed-point and floating-point formats
are still important and continue to be used in financial, commercial, and industrial computing,
where subtle conversion and fractional rounding errors that are inherent in floating point
binary representations cannot be tolerated.[7]

Basics
BCD takes advantage of the fact that any one decimal numeral can be represented by a four
bit pattern. The most obvious way of encoding digits is "natural BCD" (NBCD), where each
decimal digit is represented by its corresponding four-bit binary value, as shown in the
following table. This is also called "8421" encoding.

Decimal digit BCD

8

Other encodings are also used, including so-called "4221" and "7421" named after the
weighting used for the bits and "excess-3".[8] For example, the BCD digit 6, '0110'b in
8421 notation, is '1100'b in 4221 (two encodings are possible), '0110'b in 7421, and '1001'b
(6+3=9) in excess-3.
As most computers deal with data in 8-bit bytes, it is possible to use one of the following
methods to encode a BCD number:
Unpacked: each numeral is encoded into one byte, with four bits representing the numeral
and the remaining bits having no significance.
Packed: two numerals are encoded into a single byte, with one numeral in the least significant
nibble (bits 0 through 3) and the other numeral in the most significant nibble (bits 4 through
7).

As an example, encoding the decimal number 91 using unpacked BCD results in the
following binary pattern of two bytes:
Decimal:

Binary : 0000 1001 0000 0001

In packed BCD, the same number would fit into a single byte:
Decimal:

Binary : 1001 0001

Hence the numerical range for one unpacked BCD byte is zero through nine inclusive,
whereas the range for one packed BCD is zero through ninety-nine inclusive.
To represent numbers larger than the range of a single byte any number of contiguous bytes
may be used. For example, to represent the decimal number 12345 in packed BCD, using
big-endian format, a program would encode as follows:
Decimal:

Binary : 0000 0001 0010 0011 0100 0101

Note that the most significant nibble of the most significant byte is zero, implying that the
number is in actuality 012345. Also note how packed BCD is more efficient in storage usage
as compared to unpacked BCD; encoding the same number (with the leading zero) in
unpacked format would consume twice the storage.
Shifting and masking operations are used to pack or unpack a packed BCD digit. Other
logical operations are used to convert a numeral to its equivalent bit pattern or reverse the
process.

BCD in electronics
BCD is very common in electronic systems where a numeric value is to be displayed,
especially in systems consisting solely of digital logic, and not containing a microprocessor.
By employing BCD, the manipulation of numerical data for display can be greatly simplified
by treating each digit as a separate single sub-circuit. This matches much more closely the
physical reality of display hardwarea designer might choose to use a series of separate
identical seven-segment displays to build a metering circuit, for example. If the numeric
quantity were stored and manipulated as pure binary, interfacing to such a display would
require complex circuitry. Therefore, in cases where the calculations are relatively simple,
working throughout with BCD can lead to a simpler overall system than converting to and
from binary. Most pocket calculators do all their calculations in BCD.

The same argument applies when hardware of this type uses an embedded microcontroller or
other small processor. Often, smaller code results when representing numbers internally in
BCD format, since a conversion from or to binary representation can be expensive on such
limited processors. For these applications, some small processors feature BCD arithmetic
modes, which assist when writing routines that manipulate BCD quantities.[9][10]

Packed BCD
In Packed BCD (or simply packed decimal), each of the two nibbles of each byte represent a
decimal digit. Packed BCD has been in use since at least the 1960s and is implemented in all
IBM mainframe hardware since then. Most implementations are big endian, i.e. with the
more significant digit in the upper half of each byte, and with the leftmost byte (residing at
the lowest memory address) containing the most significant digits of the packed decimal
value. The lower nibble of the rightmost byte is usually used as the sign flag, although some
unsigned representations lack a sign flag. As an example, a 4-byte value consists of 8 nibbles,
wherein the upper 7 nibbles store the digits of a 7-digit decimal value and the lowest nibble
indicates the sign of the decimal integer value.
Standard sign values are 1100 (hex C) for positive (+) and 1101 (D) for negative (). This
convention comes from the zone field for EBCDIC characters and the signed overpunch
representation. Other allowed signs are 1010 (A) and 1110 (E) for positive and 1011 (B) for
negative. IBM System/360 processors will use the 1010 (A) and 1011 (B) signs if the A bit is
set in the PSW, for the ASCII-8 standard that never passed. Most implementations also
provide unsigned BCD values with a sign nibble of 1111 (F).[11][12][13] ILE RPG uses 1111
(F) for positive and 1101 (D) for negative.[14] These match the EBCDIC zone for digits
without a sign overpunch. In packed BCD, the number 127 is represented by 0001 0010 0111
1100 (127C) and 127 is represented by 0001 0010 0111 1101 (127D). Burroughs systems
used 1101 (D) for negative, and any other value is considered a positive sign value (the
processors will normalize a positive sign to 1100 (C)).
Sign
Digit BCD
8 4 2 1 Sign

Notes

1010+

1011

1100+

Preferred

1101

Preferred

1110+

1111+

Unsigned

No matter how many bytes wide a word is, there are always an even number of nibbles
because each byte has two of them. Therefore, a word of n bytes can contain up to (2n)1
decimal digits, which is always an odd number of digits. A decimal number with d digits
requires (d+1) bytes of storage space.
For example, a 4-byte (32-bit) word can hold seven decimal digits plus a sign, and can
represent values ranging from 9,999,999. Thus the number 1,234,567 is 7 digits wide and
is encoded as:
0001 0010 0011 0100 0101 0110 0111 1101
1

(Note that, like character strings, the first byte of the packed decimal with the most
significant two digits is usually stored in the lowest address in memory, independent of the
endianness of the machine.)
In contrast, a 4-byte binary two's complement integer can represent values from
2,147,483,648 to +2,147,483,647.
While packed BCD does not make optimal use of storage (about 1/6 of the memory used is
wasted), conversion to ASCII, EBCDIC, or the various encodings of Unicode is still trivial,
as no arithmetic operations are required. The extra storage requirements are usually offset by
the need for the accuracy and compatibility with calculator or hand calculation that fixedpoint decimal arithmetic provides. Denser packings of BCD exist which avoid the storage
penalty and also need no arithmetic operations for common conversions.
Packed BCD is supported in the COBOL programming language as the
"COMPUTATIONAL-3" (an IBM extension adopted by many other compiler vendors) or
"PACKED-DECIMAL" (part of the 1985 COBOL standard) data type. It is supported in PL/I
as "FIXED DECIMAL". Besides the IBM System/360 and later compatible mainframes,
packed BCD is implemented in the native instruction set of the original VAX processors from
Digital Equipment Corporation and some models of the SDS Sigma series mainframes, and is
the native format for the Burroughs Corporation Medium Systems line of mainframes
(descended from the 1950s Electrodata 200 series).
Ten's complement representations for negative numbers offer an alternative approach to
encoding the sign of packed (and other) BCD numbers. In this case, positive numbers always
have a most significant digit between 0 and 4 (inclusive), while negative numbers are
represented by the 10's complement of the corresponding positive number. As a result, this
system allows for, a 32-bit packed BCD numbers to range from -50,000,000 to 49,999,999,
and -1 is represented as 99999999. (As with two's complement binary numbers, the range is
not symmetric about zero.)

Fixed-point packed decimal

Fixed-point decimal numbers are supported by some programming languages (such as
COBOL and PL/I). These languages allow the programmer to specify an implicit decimal
point in front of one of the digits. For example, a packed decimal value encoded with the
bytes 12 34 56 7C represents the fixed-point value +1,234.567 when the implied decimal
point is located between the 4th and 5th digits:
12 34 56 7C
12 34.56 7+
The decimal point is not actually stored in memory, as the packed BCD storage format does
not provide for it. Its location is simply known to the compiler and the generated code acts
accordingly for the various arithmetic operations.

Higher-density encodings
If a decimal digit requires four bits, then three decimal digits require 12 bits. However, since
210 (1,024) is greater than 103 (1,000), if three decimal digits are encoded together, only 10
bits are needed. Two such encodings are Chen-Ho encoding and Densely Packed Decimal
(DPD). The latter has the advantage that subsets of the encoding encode two digits in the
optimal seven bits and one digit in four bits, as in regular BCD.

Zoned decimal
Some implementations, for example IBM mainframe systems, support zoned decimal
numeric representations. Each decimal digit is stored in one byte, with the lower four bits
encoding the digit in BCD form. The upper four bits, called the "zone" bits, are usually set to
a fixed value so that the byte holds a character value corresponding to the digit. EBCDIC
systems use a zone value of 1111 (hex F); this yields bytes in the range F0 to F9 (hex), which
are the EBCDIC codes for the characters "0" through "9". Similarly, ASCII systems use a
zone value of 0011 (hex 3), giving character codes 30 to 39 (hex).
For signed zoned decimal values, the rightmost (least significant) zone nibble holds the sign
digit, which is the same set of values that are used for signed packed decimal numbers (see
above). Thus a zoned decimal value encoded as the hex bytes F1 F2 D3 represents the signed
decimal value 123:
F1 F2 D3
1 2 3