Hubbry Logo
BCD (character encoding)BCD (character encoding)Main
Open search
BCD (character encoding)
Community hub
BCD (character encoding)
logo
7 pages, 0 posts
0 subscribers
Be the first to start a discussion here.
Be the first to start a discussion here.
BCD (character encoding)
BCD (character encoding)
BCD (character encoding)
View on Wikipedia
from Wikipedia

BCD Interchange Codes
Classification6-bit alphanumeric basic Latin encodings
Succeeded byEBCDIC

BCD (binary-coded decimal), also called alphanumeric BCD, alphameric BCD, BCD Interchange Code,[1] or BCDIC,[1] is a family of representations of numerals, uppercase Latin letters, and some special and control characters as six-bit character codes.

Unlike later encodings such as ASCII, BCD codes were not standardized. Different computer manufacturers, and even different product lines from the same manufacturer, often had their own variants, and sometimes included unique characters. Other six-bit encodings with completely different mappings, such as some FIELDATA[1] variants or Transcode, are sometimes incorrectly termed BCD.

Many variants of BCD encode the characters '0' through '9' as the corresponding binary values.

History

[edit]

Technically, binary-coded decimal describes the encoding of decimal numbers where each decimal digit is represented by a fixed number of bits, usually four.

With the introduction of the IBM card in 1928, IBM created a code[a] capable of representing alphanumeric information,[2] later adopted by other manufacturers. This code represents the numbers 0-9 by a single punch, and uses multiple punches for upper-case letters and special characters.[3] A letter has two punches (zone [12,11,0] + digit [1–9]); most special characters have two or three punches (zone [12,11,0,or none] + digit [2–7] + 8).

The BCD code is the adaptation of the punched card code to a six-bit binary code by encoding the digit rows (nine rows, plus unpunched) into the low four bits, and the zone rows (three rows, plus unpunched) into the high two bits.[4] The digit zero (a single punch in row 0) is usually handled specially in some way, and the digit code was extended to values 10 through 15 by combining a digit in the range 2–7 with a punch in row 8. IBM applied the terms binary-coded decimal and BCD to the variations of BCD alphamerics used in most early IBM computers, including the IBM 1620, IBM 1400 series, and non-Decimal Architecture members of the IBM 700/7000 series.

Among the vendors using BCD were Burroughs,[5] Bull, CDC,[6] IBM, General Electric (the computer division was purchased by Honeywell in 1969), NCR, Siemens, and Sperry-UNIVAC.

IBM announced the 8-bit Extended Binary Coded Decimal Interchange Code (EBCDIC), based on BCDIC, in 1964 with the introduction of its System/360 line.

Special characters

[edit]

The Recordmark or Record mark character (represented as ‡) is a character used to mark the end of a record.[7] The BCD code for this character is 328 in some BCD variants. The closest Unicode equivalent is U+29E7 ⧧ THERMODYNAMIC, but that is not found in many fonts, so U+2021 ‡ DOUBLE DAGGER is often used instead. Functionally this corresponds to the EBCDIC IRS character (ASCII RS), X'1E'.

The Groupmark or Group mark character (represented as ) is a character used to indicate the start or finish of a group of related fields.[8] The BCD code for this character is 778 in some BCD variants. The groupmark was proposed for Unicode standardization in 2015,[9] and was assigned to value U+2BD2 ⯒ GROUP MARK. Functionally this corresponds to the EBCDIC IGS character (ASCII GS), X'1D'. It is now in Unicode 10.0 at this position, but only the Symbola and Unifont fonts support it.

The Wordmark, by contrast, is not a BCD character. Rather, it is a flag bit used to mark the end of a word on some variable word length computers such as the IBM 1401.

BCD code variations

[edit]

There are many different versions of the six-bit BCD code. There are three major categories of difference:

  1. The mapping from zone punches to high-order bits. All codes translate no zone punches to a bit pattern of 00, but some encode the zone punches in 12-11-0 order, preserving alphabetical order, while others use 0-11-12 order, resulting in a partially reversed alphabet.
  2. The handling of the digit 0. The straightforward translation from punched form would place the blank before digits 1–9, and encode 0 at the start of the line with 'S' in it. All codes have some special-case handling which either translates the digit 0 to the all-zero binary code (and moves the blank elsewhere), or gives it binary code 001010 (decimal 10) and moves the 8+2 punch elsewhere.
  3. The assignment of special characters. The characters assigned to codes beyond the basic alphanumeric set varied widely, even within one model of computer. For example, some computers[b] had the percent and lozenge (U+2311 ⌑ SQUARE LOZENGE) at the same codes as left and right parentheses in other[c] encodings.

In "Spanish speaking countries", the character "Ñ" did not exist in the original system, therefore "@" was chosen by most manufacturers: Bull, NCR, and Control Data, but there was an inconsistency when merging databases to 7-bit ASCII code, for in that coding system the "/" character was chosen, resulting in two different codes for the same character.

Examples of BCD codes

[edit]

The following charts show the numeric values of BCD characters in hexadecimal (base-16) notation, as that most clearly reflects the structure of 4-bit binary coded decimal, plus two extra bits. For example, the code for 'A', in row 3x and column x1, is hexadecimal 31, or binary '11 0001'.

Tape style

[edit]

48-character BCD code

[edit]

The first versions of BCDIC had 48 characters, as they were based on card punch patterns and the character sets of printers, neither of which encouraged having a power-of-two number of characters.

IBM 48-character BCDIC code[1]: 68 
x0 x1 x2 x3 x4 x5 x6 x7 x8 x9 xA xB xC xD xE xF
0x space 1 2 3 4 5 6 7 8 9 0 # @
1x / S T U V W X Y Z , %
2x - J K L M N O P Q R $ *
3x & A B C D E F G H I . ⌑

This was based on a 40-character punched card code; the original 37 (10 digits, 26 letters, and blank), plus three commercially important characters added around 1932:[1]: 67  hyphen-minus used for printing credit balances and hyphenated names, the ampersand also used in many names and addresses (Procter & Gamble, Mr. & Mrs. Smith), and the asterisk used to overprint unused fields when printing cheques.

IBM 1401 BCD code

[edit]

Rather than following the IBM 704's storage representation, IBM 1401 followed the tape representation (descended from the 48-character BCD), thus using the all-zero code for blank and the code 10 (0x0A) for the digit zero. It had defined character forms for all possible values, for documentation purposes,[10] but only 48 of the 63 non-blank characters were printable, and there was considerable variation in how the other code values (shaded in the table below) were depicted in practice. Even the other characters varied between different available print chains for the IBM 1403 printer.

x0 x1 x2 x3 x4 x5 x6 x7 x8 x9 xA xB xC xD xE xF
0x space 1 2 3 4 5 6 7 8 9 0 # @ : > √
1x ¢ / S T U V W X Y Z ⧧ , % = ' "
2x - J K L M N O P Q R ! $ * ) ; Δ
3x & A B C D E F G H I ? . ⌑ ( < ⯒

Code page 353

[edit]

The BCDIC-A Code page was assigned as Code page 353, also known as CP353. Some of the characters in this code page are not in Unicode. (The duplication of '#' can be found in IBM's own documentation and is not a mistake here.[11])

x0 x1 x2 x3 x4 x5 x6 x7 x8 x9 xA xB xC xD xE xF
0x space 1 2 3 4 5 6 7 8 9 0 # @ : > √
1x ␢ / S T U V W X Y Z ⧧ , % γ \ ⧻
2x - J K L M N O P Q R ! # * ] ; Δ
3x & A B C D E F G H I ? . ⌑ [ < ⯒

At 0x1A is the record mark. At 0x3F is the group mark.

Code page 354

[edit]

The BCDIC-B Code page was assigned as Code page 354, also known as CP354.[12] Some of the characters in this code page are not in Unicode.

x0 x1 x2 x3 x4 x5 x6 x7 x8 x9 xA xB xC xD xE xF
0x space 1 2 3 4 5 6 7 8 9 0 ⊙ ' : > √
1x ␢ / S T U V W X Y Z ⧧ , ( γ \ ⧻
2x - J K L M N O P Q R ! # * ] ; Δ
3x + A B C D E F G H I ? . ) [ < ⯒

At 0x1A is the record mark. At 0x3F is the group mark.

PTTC/BCD code pages

[edit]

PTTC/BCD had 5 options. There were five code pages. They are shown below. The PTTC/BCD Standard Option was assigned as Code page 355, or CP355.

x0 x1 x2 x3 x4 x5 x6 x7 x8 x9 xA xB xC xD xE xF
0x space 1 2 3 4 5 6 7 8 9 0 #
1x @ / S T U V W X Y Z ⧧ , γ
2x - J K L M N O P Q R < $
3x & A B C D E F G H I ) .

The PTTC/BCD H Option was assigned as Code page 357, or CP357.

x0 x1 x2 x3 x4 x5 x6 x7 x8 x9 xA xB xC xD xE xF
0x space 1 2 3 4 5 6 7 8 9 0 =
1x ' / S T U V W X Y Z ⧧ ,
2x - J K L M N O P Q R ! $
3x + A B C D E F G H I ? .

The PTTC/BCD Correspondence Option was assigned as Code page 358, or CP358.

x0 x1 x2 x3 x4 x5 x6 x7 x8 x9 xA xB xC xD xE xF
0x space 1 2 3 4 5 6 7 8 9 0 '
1x ! / S T U V W X Y Z ⧧ ,
2x - J K L M N O P Q R < ;
3x = A B C D E F G H I > .

The PTTC/BCD Monocase Option was assigned as Code page 359, or CP359.

x0 x1 x2 x3 x4 x5 x6 x7 x8 x9 xA xB xC xD xE xF
0x space 1 2 3 4 5 6 7 8 9 0 #
1x @ / S T U V W X Y Z ,
2x - J K L M N O P Q R $
3x & A B C D E F G H I .

The PTTC/BCD Duocase Option was assigned as Code page 360, or CP360.

x0 x1 x2 x3 x4 x5 x6 x7 x8 x9 xA xB xC xD xE xF
0x space 1 2 3 4 5 6 7 8 9 0 #
1x @ / S T U V W X Y Z ,
2x - J K L M N O P Q R $
3x & A B C D E F G H I .

IBM 704 storage style

[edit]

IBM 704 BCD code

[edit]

The IBM 704 reordered the BCDIC code to allow a normal alphabetic collating order internally, with 0 before 1 and A before Z. It could automatically translate between this internal form and the earlier BCDIC when reading and writing magnetic tapes.[13]: 35 

The following table shows the code assignments for the IBM 704 computer. Unassigned code positions appear as blanks.[13]: 35 

IBM 704 character set
x0 x1 x2 x3 x4 x5 x6 x7 x8 x9 xA xB xC xD xE xF
0x 0 1 2 3 4 5 6 7 8 9 # @
1x & A B C D E F G H I +0 . ⌑
2x - J K L M N O P Q R −0 $ *
3x space / S T U V W X Y Z ⧧ , %

(+0 and −0 were rarely used characters that corresponded to the punched-card convention of a digit 0 with an overpunched sign in rows 12 or 11.)

The following table shows the code assignments for the type 716 printer used starting with the IBM 704 computer and through the 7094.[13]: 58  The 704 interface[d] sent virtual punched-card rows to this printer, two words (72 bits) at a time, so the mapping from 6-bit BCD characters was done by software, and was not built into the printer.

IBM 716 printer character set G
x0 x1 x2 x3 x4 x5 x6 x7 x8 x9 xA xB xC xD xE xF
0x * 1 2 3 4 5 6 7 8 9 + -
1x + A B C D E F G H I . ⌑
2x - J K L M N O P Q R $ *
3x 0 / S T U V W X Y Z , %

This is a repertoire of 45 characters (not counting blank, which is handled specially by the printer), as the characters +, - and * are duplicated.

Fortran character set

[edit]

There was some variation; IBM 704 Fortran had a different set of special characters (preserving only the duplicated minus sign and asterisk, period, comma, and dollar sign).[14]

IBM 716 printer Fortran character set
x0 x1 x2 x3 x4 x5 x6 x7 x8 x9 xA xB xC xD xE xF
0x * 1 2 3 4 5 6 7 8 9 = -
1x + A B C D E F G H I . )
2x - J K L M N O P Q R $ *
3x 0 / S T U V W X Y Z , (

A similar code was used for the IBM 709, 7090 and 7094 successors,[15] but with some of the special characters reassigned:

IBM 7090/7094 character set
x0 x1 x2 x3 x4 x5 x6 x7 x8 x9 xA xB xC xD xE xF
0x 0 1 2 3 4 5 6 7 8 9 = "
1x & A B C D E F G H I +0 . )
2x - J K L M N O P Q R −0 $ *
3x space / S T U V W X Y Z ± , (

GBCD code

[edit]

Below is the table of GE/Honeywell's GBCD code, a variant of BCD.[16]

x0 x1 x2 x3 x4 x5 x6 x7 x8 x9 xA xB xC xD xE xF
0x 0 1 2 3 4 5 6 7 8 9 [ # @ : > ?
1x space A B C D E F G H I & . ] ( < \
2x ^ J K L M N O P Q R - $ * ) ; '
3x + / S T U V W X Y Z _ , % = " !

Burroughs B5500 BCD code

[edit]

The following table shows the code assignments for the Burroughs B5500 computer, sometimes referred to as BIC (Burroughs Interchange Code).[17]

x0 x1 x2 x3 x4 x5 x6 x7 x8 x9 xA xB xC xD xE xF
0x 0 1 2 3 4 5 6 7 8 9 # @ ? : > ≥
1x + A B C D E F G H I . [ & ( < ←
2x × J K L M N O P Q R $ * - ) ; ≤
3x space / S T U V W X Y Z , % ≠ = ] "

See also

[edit]

Notes

[edit]

References

[edit]

Further reading

[edit]
Revisions and contributorsEdit on WikipediaRead on Wikipedia

BCD (character encoding)

View on Grokipedia
from Grokipedia
BCD (character encoding), also known as alphanumeric BCD, alphameric BCD, BCD Interchange Code, or BCDIC, is a family of 6-bit representations primarily developed by for encoding numerals, uppercase letters, and special characters in early computing systems, building on principles where each decimal digit uses four bits and additional zone bits handle alphabetic and symbolic data. This encoding scheme emerged in the 1950s for punched card systems and early computers like the and , where data was stored using bit positions labeled B, A, 8, 4, 2, 1; the B and A bits served as zone bits set to zero for numeric digits but adjusted for letters (e.g., 110001 for A) and symbols, enabling 64 distinct characters in variants such as the commercial BCD-A or FORTRAN-oriented BCD-H used in the IBM 026 . It facilitated decimal arithmetic and human-readable in business applications, avoiding the complexities of pure binary for financial calculations. By the 1960s, BCDIC evolved into the 8-bit Extended Binary Coded Decimal Interchange Code () for 's System/360 mainframes, incorporating zoned BCD with upper "zone" bits (often 1111) for characters alongside lower digit nibbles, while retaining compatibility with legacy BCD systems; though largely superseded by ASCII in modern computing, variants persist in IBM mainframes for legacy data processing and applications.

Fundamentals

Definition and Encoding Principles

Binary-Coded Decimal (BCD), in the context of character encoding, refers to a 6-bit binary code developed by IBM for representing alphanumeric characters and symbols in early computing systems. This encoding scheme utilizes 6 bits to encode up to 64 distinct characters, including the decimal digits 0-9, uppercase letters A-Z, and a selection of basic punctuation and special symbols, making it suitable for business data processing applications. Unlike pure binary representations, BCD adapts the binary-coded decimal method—originally for numeric values—to a character set by incorporating additional bits for categorization. The structure of BCD divides the 6 bits into two main components: 2 zone bits (often labeled as B and A bits, with B as MSB and A next) in the upper positions and 4 digit bits (labeled 8, 4, 2, 1) in the lower positions. The zone bits distinguish between numeric digits and other character types, such as letters or specials; for instance, zone bits set to 00 indicate numeric digits 0-9 or letters S-Z, 01 for A-I, and 10 for J-R. The digit bits encode the specific value within that category using a standard 8421 weighted for decimals 0-9. Representative binary mappings include 000000 for the digit 0 (zone 00, digit 0000) and 010001 for the letter A (zone 01, digit 0001), illustrating how the combined bits directly correspond to row positions in early hardware (B=0 for no row 11, A=1 for row 12, 1=1 for row 1). In operation, BCD encoding principles ensure that each decimal digit is represented independently in its 4-bit form, preventing the overflow issues common in pure binary arithmetic where carrying over might complicate decimal alignments. This direct mapping allows arithmetic operations to manipulate digits as discrete units, simplifying and in decimal-based computations without conversion steps. For early electromechanical systems, such as those using decimal tabulators, BCD offered key advantages over pure binary by maintaining compatibility with existing infrastructure and human-readable decimal formats, thereby facilitating seamless data handling in business environments without requiring full binary redesigns.

Character Set Composition

The BCD character encoding, formally known as Interchange Code (BCDIC), features a standard repertoire of 48 characters optimized for early data processing systems. This composition breaks down into three primary categories: 10 numeric digits (0 through 9), 26 uppercase letters (A through Z), and 12 special symbols, including the space, , period, , plus sign, minus sign, , slash, , (#), commercial at (@), and equals sign. The fixed 48-character baseline set arises from the practical limitations of punch card and printer technologies in the mid-20th century, utilizing a 6-bit structure that inherently supports up to 64 distinct codes, with extensions achieved in some variants by assigning the remaining 16 codes to additional symbols via optional hardware features or modified chains. Reflecting its origins in decimal arithmetic and business tabulation, BCD places strong numeric emphasis in its encoding, where the digits directly correspond to binary representations in the lower four bits—such as 0000 for 0 and 0001 for 1—allowing seamless integration with BCD numeric storage formats. Core BCD lacks support for lowercase letters, diacritical accents, or an extensive punctuation repertoire beyond the basic 12 symbols, positioning it as a specialized encoding for unadorned English alphanumeric data rather than multilingual or typographically rich text.

Historical Context

Origins and Early Adoption

The concept of (BCD) encoding traces its roots to the late 19th century, when developed punched card systems for , initially to tabulate the 1890 U.S. Census. Hollerith's cards used holes in specific positions to represent digits and limited alphabetic characters, embodying an early form of decimal encoding that avoided full binary representations to align with human-readable numerical data. This approach was inspired by earlier punched systems like Jacquard looms but adapted for electromechanical tabulation, enabling efficient sorting and counting without complex conversions. By the 1920s, as the (later renamed in 1924) expanded Hollerith's technology, encoding evolved into a standardized 6-bit BCD format for tabulating machines. The 1928 introduction of the 80-column card, with 12 punch rows (zones 0, 11, 12 and numerics 1-9, 0), allowed 64 combinations per column, supporting numeric BCD (4 bits for 0-9) plus 2 zone bits for alphabetic and special characters. This 6-bit structure facilitated decimal arithmetic in business applications, such as and , by directly mapping card punches to decimal values readable by sorters and tabulators. A key milestone occurred in the 1930s with the adoption of BCD in 's electromechanical accounting machines, such as the IBM 405 and related Type I series, which standardized a 48-character set for business . These machines integrated readers with arithmetic units, using BCD to process , billing, and statistical data while maintaining compatibility with existing card infrastructure. The drivers for this adoption included the need for seamless decimal handling in financial computations and the simplicity of 6-bit codes over emerging 7- or 8-bit binary schemes, which would have required costly hardware redesigns for legacy tabulators.

Development in IBM Systems

In the , BCD evolved significantly within 's early electronic computing systems, transitioning from mechanical origins to standardized electronic representations. The , introduced in 1952 as IBM's first commercial scientific computer, adopted a 6-bit BCD encoding to handle numeric and alphanumeric data, supporting up to 48 characters including digits, uppercase letters, and basic specials for scientific applications. This encoding facilitated efficient data processing in the system's memory, building briefly on earlier formats for input compatibility. The , released in 1954, refined this approach with enhancements for advanced scientific computing, including floating-point hardware and instructions like Convert and Compare for BCD sorting. It maintained 6-bit BCD for characters while introducing storage variations optimized for its , where six characters could be packed into 36-bit words, improving density and performance over the 701's electrostatic storage. These adaptations ensured with 701 peripherals while addressing the demands of more complex computations. A pivotal advancement occurred with the in 1959, tailored for commercial and becoming one of IBM's most successful machines with over 10,000 units shipped. The 1401 employed BCDIC, a formalized 6-bit variant expanding the repertoire to 48-64 characters—including numerics, alphabets, and business-oriented specials like currency symbols—while ensuring compatibility with 7-track for data interchange. Its architecture packed characters into 8-bit core storage units (6 data bits plus check and word mark bits), enabling variable-length fields for flexible record handling in accounting and inventory tasks. BCD's influence extended to peripherals, where punch card readers (such as the 533 or 552 models) and line printers (like the 1403) were designed around 6-bit encoding for seamless translation from 12-row Hollerith cards to electronic formats, minimizing conversion overhead and supporting high-volume at speeds up to 600 cards per minute. This optimization stemmed from BCD's direct mapping of punch positions to bit patterns, enhancing reliability in electromechanical interfaces. The timeline of BCD standards progressed from these basic implementations in the 701 and 704—focused on 48-character sets—to more robust BCDIC variants by the late , culminating in precursors to . BCDIC was officially standardized in 1962 under Corporate Systems Standard CSS 3-2-8015-0, providing a 64-position code that addressed collating inconsistencies and paved the way for the 8-bit in the 1964 System/360 announcement.

Core Elements

Standard Character Mapping

The standard character mapping in BCD (Binary Coded Decimal) encoding uses a 6-bit binary representation to a core set of 48 characters, consisting of the 10 digits, 26 uppercase letters, and 12 special characters. This mapping is derived directly from the code, where each column's hole pattern is translated into binary bits, with the low 4 bits representing the digit rows (1-9 and unpunched for ) and the high 2 bits representing the zone rows (12, 11, or 0). The resulting 6-bit codes allow for 64 possible combinations, of which 48 are assigned to the standard repertoire, with the remainder reserved or unused. The mapping logic follows a structured zone-digit scheme. Decimal digits 0-9 are encoded with zone bits 00 followed by digit bits 0000 to 1001 (e.g., 0 as 000000, 9 as 001001). Uppercase letters are grouped by zone: A-I use zone 11 (binary 11) plus digit bits 0001-1001 (e.g., A as 110001); J-R use zone 10 (binary 10) plus digit bits 0001-1001 (e.g., J as 100001); S-Z use zone 01 (binary 01) plus digit bits 0010-1001 (e.g., S as 010010, skipping 0001 to avoid overlap with digits). Special characters occupy remaining combinations, using zone-digit pairs or multi-punch equivalents translated to unique 6-bit codes (e.g., zone 10 with digit 0000 for the minus sign as 100000). This design ensures compatibility with punched card readers, where each 6-bit code corresponds to specific hole positions in the 12-row card format (rows 12 for zone A, 11 for zone B, 0 for zone C, and 1-9 for numeric digits). Note that in storage variants like the , numeric 0 is remapped to 001010 (bits 8 and 2 set) to distinguish it from blank (000000), while maintaining compatibility with punched card input. The following table presents the full 48-character standard BCD mapping for alphanumeric characters, including the character, its decimal equivalent (the integer value of the 6-bit binary), the 6-bit binary code (MSB to LSB), and the zone-digit breakdown. Special characters have unique codes not listed here to avoid variant-specific overlaps; see variants section for details. Decimal equivalents are provided for reference in binary-to-decimal conversions common in early IBM systems.
CharacterDecimalBinary (6-bit)Zone-Digit Breakdown
0000000000-0000
1100000100-0001
2200001000-0010
3300001100-0011
4400010000-0100
5500010100-0101
6600011000-0110
7700011100-0111
8800100000-1000
9900100100-1001
A4911000111-0001
B5011001011-0010
C5111001111-0011
D5211010011-0100
E5311010111-0101
F5411011011-0110
G5511011111-0111
H5611100011-1000
I5711100111-1001
J3310000110-0001
K3410001010-0010
L3510001110-0011
M3610010010-0100
N3710010110-0101
O3810011010-0110
P3910011110-0111
Q4010100010-1000
R4110100110-1001
S1801001001-0010
T1901001101-0011
U2001010001-0100
V2101010101-0101
W2201011001-0110
X2301011101-0111
Y2401100001-1000
Z2501100101-1001
-3210000010-0000
/1701000101-0001
,1601000001-0000
"4811000011-0000
Note that full sets may vary slightly by implementation, such as in FORTRAN-oriented variants where some letter codes are reassigned to specials like $ or %. Equivalences to hole patterns are direct, but bit mapping can vary; for example, A (110001) corresponds to punches in rows 12 and 1 in standard mapping, with zone bits set accordingly. Ambiguities, such as the code 000000 representing both the digit 0 (in numeric mode) and (in alphabetic mode), are resolved through system , such as word separators or mode flags in equipment. For instance, in numeric fields, 000000 is interpreted as 0, while in text fields, it denotes blank . In storage, however, 000000 is always blank, and numeric 0 uses 001010.

Control and Special Characters

In BCD character encoding, control characters encompass a small set of non-printable codes, typically numbering 8 to 16, that manage device operations and data flow in early computing systems such as the IBM 1401. These codes, encoded in 6-bit binary format, include essential formatting signals like (CR), line feed (LF), horizontal tab (HT), and end-of-record (EOR) markers, which direct hardware behavior without producing visible output. For example, carriage control on the IBM 1403 printer is achieved using specific characters with zone punches (e.g., codes with B or A bit set) that correspond to positions on the carriage control tape, enabling structured text layout in tasks. Similarly, line feed is triggered by designated codes advancing the paper by one line, often combined with carriage control for complete line breaks in output streams. These control codes integrate seamlessly into data sequences, interleaving with alphanumeric characters to control formatted and tape handling. In printer operations, such as those on the 1403 at speeds up to 600 lines per minute, a sequence might embed control characters after a line of text to position the next print cycle correctly, while HT shifts the carriage to tab stops for column alignment in reports or tables. On magnetic tapes like the 729, EOR markers—such as the record mark (punches 0-2-8, 001010, represented as the & )—signal the end of a data block, prompting the to halt reading or writing and transition to the next record. This interleaving ensures efficient, error-free processing of variable-length fields in business applications. Special characters in BCD, distinct from pure controls but often serving formatting roles, include symbols like the dollar sign ($), slash (/), and percent (%), encoded using upper zone bits (B and A) combined with numeric bits for differentiation from letters and digits. The dollar sign is mapped to a unique 6-bit code such as 100011 (zone 10-digit 3) in standard commercial variants, denoting currency in financial records and remaining stable during editing operations. The slash (zone 0-digit 1, binary 010001) acts as a date or division separator in data fields, while the percent (zone 0 with multi-punch 4-8, binary 011100) indicates percentages in computations or reports. These symbols enhance readability in interleaved sequences, appearing alongside controls to format output for punch cards or printed media. BCD's unique hardware-specific features extend control functionality to punch card and tape mechanisms, where codes like the group mark (12-7-8, binary 111111 or special handling) and word mark (overlaid on the 8th bit) facilitate field delimitation and detection via odd-parity checks. Group marks organize data blocks on tapes, automatically stopping feed operations to prevent overrun, while word marks define instruction boundaries in core storage, supporting variable-word-length processing essential for the 1401's efficiency in decimal arithmetic and I/O. These elements, integral to BCD's design, optimized early workflows by embedding control directly into character streams, reducing overhead in legacy hardware.

Code Variations

Tape-Oriented BCD Variants

Tape-oriented BCD variants adapted the core 6-bit binary-coded decimal encoding principles for sequential storage and transmission on magnetic and paper tapes, prioritizing error detection and media-specific optimizations. Introduced in the 1950s alongside IBM's 7-track magnetic tape systems, these variants packed 6 data bits per character into 7-bit words, with the seventh track dedicated to a parity bit for reliability during read/write operations. Even parity was standard for BCD-coded tapes, ensuring an even number of 1s across the seven bits to detect single-bit errors in transit. This configuration supported bit-serial transmission, where data flowed sequentially along the tape length, contrasting with parallel storage formats. The foundational 48-character BCD tape code formed the basis of these variants, encoding a , digits through 9, uppercase letters A through Z, and 11 special symbols derived from early conventions. This limited set maximized compatibility with commercial while fitting the 6-bit constraint, allowing two characters to be stored efficiently per 12-bit frame on tape. For broader applications, the BCD variant extended this with additional control and graphic characters tailored for commercial tape workflows, such as record delimiters and numeric zones. European code pages 353 (BCDIC-A) and 354 (BCDIC-B) further modified the set by substituting U.S.-specific specials with diacritics like , , and to support national languages, maintaining through dual-coding schemes. Paper tape implementations followed an 8-channel standard, incorporating a hole for mechanical feed alongside 7 data channels (6 bits plus parity). punching patterns directly mirrored the BCD bit assignments, with presence of a denoting a 1 and absence a 0, enabling reliable optical or mechanical reading at speeds up to 1000 characters per second. These patterns optimized for minimal (punched debris) and error resistance, using combinations like single- punches for digits and multi-hole for letters. Such adaptations facilitated between and magnetic media in early environments. A primary advantage of tape-oriented BCD was its high storage density, enabling efficient archival and bulk data transfer; 7-track tapes achieved up to 200 characters per inch in initial models, scaling to 800 characters per inch by the mid-1960s through improved recording techniques. This density supported reels holding millions of characters, far surpassing punched cards for large-scale tasks.

Storage-Oriented BCD Variants

Storage-oriented BCD variants adapted the 6-bit encoding for use in core memory and systems of mid-1950s computers, prioritizing efficient packing and support for in-memory operations over serial transmission concerns. These variants packed multiple characters into fixed-word architectures, such as 36-bit or 48-bit words, while incorporating bits to denote attributes like sign and overflow, enabling and decimal arithmetic without frequent unpacking. This contrasted with tape-oriented approaches by focusing on computational efficiency in environments, where quick -based indexing facilitated arithmetic and manipulation. In 704-era systems, BCD characters were encoded using 6 bits each, with six characters packed into a single 36-bit core memory word to optimize storage density for alphanumeric data. Numeric representations included dedicated flag bits within the word structure to indicate sign magnitude and potential overflow conditions, supporting direct decimal addition, , and in memory. This packing scheme allowed for seamless integration with the system's binary floating-point hardware, where BCD data could be converted on-the-fly for mixed scientific and business workloads. The Burroughs B5500 employed an octal-based BCD variant tailored for its 48-bit word architecture, packing eight 6-bit characters per word in character mode or using 13 octades (3 bits each) for numeric mantissas in floating-point form. Flag bits, including those for positive/negative sign (bit 1), exponent sign (bit 2), and logical true/false (bit 47), were embedded to control decimal operations and , with overall word parity ensuring memory reliability during . This design emphasized decimal arithmetic in core storage, aligning with the system's ALGOL-oriented and stack-based execution. Common packing methods across these variants maximized word utilization, such as the six-character arrangement in 36-bit words or eight in 48-bit words, while flag bits—typically 1 to 3 per relevant field—provided metadata for sign, overflow, and type identification without requiring separate storage overhead. These features enabled efficient for editing and computation, distinguishing storage-oriented BCD from linear tape formats that emphasized parity over embedded flags.

Key Implementations

The , a variable-wordlength system introduced in 1959, employed a 6-bit (BCD) encoding scheme optimized for commercial applications such as payroll, inventory, and billing. This encoding supported a 48-character set comprising uppercase letters (A-Z), digits (0-9), space, and special symbols including $, #, @, %, *, -, +, /, ,, ., and =. The structure utilized two zone bits (B and A) for alphabetic and control distinctions alongside four numeric bits (8, 4, 2, 1) for values, enabling direct compatibility with and tape formats prevalent in business environments. In core memory, each character occupied one storage position, with overall capacity ranging from 1,400 to 16,000 positions depending on configuration, allowing storage of variable-length records delimited by word marks—a special bit per character to mark field boundaries. This facilitated flexible processing of business data without fixed record sizes, as instructions and operands could span arbitrary lengths up to the full memory, with addresses specified in BCD for direct decimal interpretation. For input/output, the BCD encoding integrated seamlessly with devices like the IBM 1402 card reader-punch and 1403 printer, converting punched card columns (using 12-row Hollerith code) to internal 6-bit representations, while magnetic tape used a 7-track variant with an added parity bit for error detection and inter-record gaps of 3/4 inch to separate variable-length blocks. Tape extensions included compressed modes and A-bit modifications for blank suppression, enhancing efficiency in data transfer for large-scale commercial batches. The BCD scheme's binary assignments exemplified its decimal-oriented design; for instance, the space character was encoded as 110000 (zone bits B=1, A=1; numeric bits 0000), distinguishing it from numeric (000000) and enabling padding in fixed-width fields without altering arithmetic operations. In practice, this supported COBOL-like through assembly languages such as Autocoder, where variable-length records handled mixed alphanumeric and numeric fields for tasks like report generation. A representative record, such as "AMT 123.45" denoting an amount, would use zone bits for letters A, M, T and numeric bits for the digits and point, with zone bits adjusted for sign or editing as needed in output formatting. Related variants extended the core BCD for international use, particularly in . Code page 353, known as BCDIC-A, adapted the 6-bit set for UK applications by incorporating the pound symbol (£) in positions typically assigned to other specials like #, maintaining compatibility with 1401 hardware while supporting localized currency processing. Similarly, code page 354 (BCDIC-B) modified the encoding for French locales, replacing select characters with accented forms such as (in the E position) and , to accommodate national alphabets in and without altering the underlying BCD structure. PTTC/BCD pages, including 355 (standard option) and 357 (H option), further adapted BCD for telegraph and perforated tape transmission, emphasizing error-resistant 6-bit codes with options for monocase or duocase handling to interface 1401 systems with early networks.

IBM 704 and Fortran Adaptations

The utilized a 6-bit BCD storage code supporting 64 distinct characters, encompassing uppercase letters, digits, and special symbols essential for scientific . This encoding incorporated zone bits—derived from punched card conventions—as flag bits to differentiate numeric digits (using a 4-bit field for values 0-9) from alphabetic and symbolic characters (using 2-bit zone flags such as 00 for numeric, 11 or 12 for alphabetic). The numeral zero was uniquely encoded as the all-zero bit pattern 000000, optimizing internal numeric operations on the machine's 36-bit words, where six such characters could be packed. This BCD variant reordered traditional encodings to support alphabetic collating sequences, with digits preceding letters in binary order (e.g., 'A' at 110001, following '9' at 100111). Special symbols were assigned to unused combinations, enabling representation of mathematical operators; for instance, common symbols like the equals sign were mapped to specific 6-bit patterns such as 101100. The structure allowed flexible storage of alphanumeric data, with flag bits facilitating zone detection for sorting and conversion routines. The programming language adapted this BCD encoding for its character set in FORTRAN I, released in 1957 specifically for the 704. Extensions included symbols for , such as the plus (+) and minus (-) signs for numeric values and exponents, and the letter E to denote exponential notation (e.g., 5.0E3 representing 5.0 × 10³). These additions built upon the core 48-character BCD set, filling additional slots to support formatted without requiring full 7- or 8-bit extensions, while maintaining compatibility with the 704's word-packing constraints. Input via punched cards or BCD tape used this extended set, with blanks encoded as 110000 to pad identifiers up to six characters per word. A generalized variant, GBCD, emerged in successors to the 704, such as the series, expanding the BCD framework to accommodate international characters by reassigning flag bits for accented letters and diacritics while preserving core numeric compatibility. This adaptation addressed growing needs for multilingual in scientific applications. (Note: While primarily associated with implementations, GBCD principles influenced IBM's evolving BCD usage in 704-derived systems.) In early Fortran compilers for the 704, BCD encoding enabled mixed alphanumeric-numeric computations by providing dedicated subroutines for input/output conversion: symbolic expressions and constants were read as BCD strings, parsed for operators and variables, then translated to binary floating-point for arithmetic execution (using 27-bit mantissas for approximately 8 decimal digits of precision). Output reversed this process, formatting binary results back to BCD for printing or tape storage, with carriage control via the first character's zone bits—thus streamlining the handling of hybrid code like algebraic formulas alongside numerical data. This integration was pivotal for FORTRAN I's efficiency on the 704, reducing overhead in symbolic manipulation.

Non-IBM BCD Codes

While IBM dominated BCD implementations, other vendors developed proprietary variants tailored to their hardware architectures, often using 6-bit codes to encode alphanumeric characters and controls for tasks. Burroughs Corporation's B5500 system, introduced in the mid-1960s, employed a 6-bit BCD code known as Burroughs Common Language (BCL), which supported 64 characters including uppercase letters, digits, and 28 special symbols. This encoding used bits labeled B, A, 8, 4, 2, and 1, with characters stored in 48-bit words accommodating up to eight per word in character mode; numeric data incorporated a in the least significant character, where B=1 and A=0 indicated negative values. For programming, the code facilitated unique mappings, such as the group mark (functioning as a field mark to terminate operations like tape writes) represented in as 37, enabling efficient string processing and operations inherent to Burroughs' stack-based design. Honeywell's Series 200 computers, launched in 1963, utilized a similar 6-bit BCD encoding for alphanumeric and special characters, combining numeric bits (1, 2, 4, 8) with zone bits A and B to represent data in variable-length fields. Custom control characters were integrated for peripherals like printers and tapes, supporting character-oriented processing in systems such as the H200, which handled both BCD arithmetic and binary modes. UNIVAC I, delivered starting in 1951, adapted BCD with excess-3 notation for digits (adding 3 to the binary value, e.g., 0 as 0011), using 6-bit characters with 4 numeric bits and 2 zone bits. Instructions and data were packed into 120-bit words, accommodating 20 such characters. These non-IBM BCD variants featured vendor-specific extensions, such as Burroughs' emphasis on octal-aligned modular arithmetic for efficient stack operations and Honeywell's flexible field lengths for business data handling, diverging from IBM's punch-card-centric mappings to optimize proprietary peripherals and instruction sets. Though less widespread than IBM's due to compatibility silos, these implementations influenced pre-ASCII standardization efforts in the 1960s, as vendors like Honeywell and UNIVAC participated in X3.2 committees, contributing diverse character sets that shaped the 7-bit ASCII code's balance of data processing and communications needs.

Applications and Impact

Usage in Data Processing

BCD (Binary Coded Decimal) played a central role in early systems by enabling the direct representation of decimal digits in , facilitating accurate handling of numerical without conversion errors common in pure binary systems. One of its primary applications was encoding information on 80-column punch cards, where the Hollerith code served as a mechanical precursor to BCD by using hole positions to represent characters, later translated into 6-bit BCD for computer input. Similarly, BCD was employed on magnetic tapes to store compact records for and inventory management, allowing systems to process large volumes of transactional efficiently. In typical workflows, data entry began with keypunch machines like the 026 or 029, where operators punched BCD-encoded characters into cards based on source documents such as invoices or ledgers. These cards were then fed into tabulators or sorters for batch organization, such as alphabetically sorting customer records or numerically collating levels, with BCD ensuring decimal integrity during mechanical and early electronic tabulation. Output generation involved transferring processed BCD to printers, like the 1403, which printed reports at speeds up to 1400 lines per minute by interpreting the code to drive type slugs on a rotating . Control characters in BCD, such as carriage returns, aided in formatting these I/O operations for readable reports. BCD's decimal-native structure was particularly advantageous in hardware accelerators for arithmetic operations within systems like the , a transistor-based computer introduced in 1959 that processed BCD data at high speeds for applications. The 1401's allowed for high-speed decimal arithmetic operations, leveraging dedicated BCD adders to handle tasks like calculations or balancing far faster than manual methods. In the , BCD via the saw widespread adoption in banking for automating check processing, where (MICR) data was converted to BCD punch cards for sorting and account reconciliation at rates supporting thousands of transactions daily. Similarly, U.S. Census Bureau operations utilized BCD-encoded punch cards to tabulate demographic data from the 1960 census, processing millions of records to generate statistical reports on population and economics.

Transition to Successor Encodings

In the mid-1960s, IBM shifted from 6-bit BCD encodings to the 8-bit Extended Binary Coded Decimal Interchange Code (EBCDIC), introduced in 1964 alongside the System/360 mainframe series. EBCDIC extended BCD by incorporating support for lowercase letters, additional control characters, and enhanced compatibility with legacy punch card systems, while preserving the decimal-oriented structure for business data processing. This transition addressed the limitations of BCD's restricted character set in handling growing computational demands. In parallel, the 7-bit American Standard Code for Information Interchange (ASCII), standardized by ANSI as X3.4-1963, emerged as a rival encoding with a broader international focus, supporting alphabetic, numeric, and characters for diverse applications beyond decimal-centric tasks. Unlike BCD's emphasis on efficient for and tabulation, ASCII prioritized compatibility with protocols and cross-vendor , factors that propelled its widespread adoption over proprietary systems like . By 1967, ASCII's international ratification via ISO 646 further solidified its dominance in non-IBM environments. BCD's influence endured in IBM ecosystems, where packed decimal formats—a compact BCD variant storing two digits per byte—remain integral to for precise decimal arithmetic in financial and scientific computing. programming, designed for business applications, continues to leverage BCD-derived decimal handling to ensure accurate representation of monetary values without floating-point rounding errors. These legacies highlight BCD's foundational role in maintaining decimal integrity amid broader shifts to byte-oriented encodings.

References

  1. https://www.idc-online.com/technical_references/pdfs/electronic_engineering/Binary_Coded_Decimal.pdf
  2. https://homepage.divms.uiowa.edu/~jones/cards/codes.html
  3. https://ibm-1401.info/1401GuidePosterV9.html
  4. https://bitsavers.trailing-edge.com/pdf/ibm/360/training/SR29-0231-5_System360_Assembler_Coding_System_Review_196811.pdf
  5. https://www.eejournal.com/article/mysteries-of-the-ancients-binary-coded-decimal-bcd/
  6. https://bitsavers.trailing-edge.com/pdf/ibm/1401/A24-1403-5_1401_Reference_Apr62.pdf
  7. https://ibm-1401.info/KShirriff-1406.html
  8. https://ibm1401.computerhistory.org/VansOverview.html
  9. http://www.edwardbosworth.com/CPSC2105/Lectures/Slides_06/Chapter_02/CharacterCodes.pdf
  10. https://www.ibm.com/history/punched-card-tabulator
  11. https://www.ibm.com/history/punched-card
  12. https://hcs64.com/files/Mackenzie%20-%20Coded%20Character%20Sets%20History%20and%20Development.pdf
  13. https://ibm-1401.info/Van1401-CodeChart.pdf
  14. https://www.righto.com/2015/10/qui-binary-arithmetic-how-1960s-ibm.html
  15. https://ibm-1401.info/PunchedCardTypography.html
  16. https://simh.trailing-edge.com/pdf/i1401_doc.pdf
  17. https://bitsavers.org/pdf/ibm/1401/Programming_the_1401_1962.pdf
  18. https://www.curiousmarc.com/computing/ibm-1401-mainframe/ibm-1401-programming
  19. https://www.aivosto.com/articles/charsets-codepages.html
  20. http://www.columbia.edu/cu/computinghistory/704.html
  21. https://archive.computerhistory.org/resources/text/Fortran/102649787.05.01.acc.pdf
  22. https://www.math.utah.edu/~beebe/software/fortran-documentation/ftnsum.pdf
  23. https://www.ibiblio.org/apollo/Documents/FortranIIforIBM704-IBM-C28-6000.pdf
  24. https://en.wikibooks.org/wiki/Character_Encodings/Code_Tables/EBCDIC/EBCDIC_1047
  25. https://bitsavers.org/pdf/ibm/fortran/FORTRAN_704_709_Systems_Manual-1960.pdf
  26. https://bitsavers.computerhistory.org/pdf/burroughs/LargeSystems/B5000_5500_5700/1021326_B5500_Reference_Manual_196809.pdf
  27. http://bitsavers.informatik.uni-stuttgart.de/pdf/honeywell/series200/charlie_gibbs/WP-8324_Models_200-1200-2200_Programmers_Reference_Manual.pdf
  28. http://www.bitsavers.org/pdf/univac/univac1/UNIVAC1_Operating_Manual_1954.pdf
  29. https://ia601805.us.archive.org/24/items/enf-ascii/ascii.pdf
  30. http://bitsavers.trailing-edge.com/pdf/ibm/1401/A24-1401-1_1401_System_Summary_Sep64.pdf
  31. http://www.columbia.edu/cu/computinghistory/026.html
  32. http://www.columbia.edu/cu/computinghistory/1401.html
  33. https://www.youtube.com/watch?v=B0Kc0-Kvww0
  34. https://americanhistory.si.edu/collections/object-groups/punch-cards/punch-cards-data-processing
  35. https://www.redbooks.ibm.com/redbooks/pdfs/sg246366.pdf
  36. http://www.simotime.com/datapk01.htm
Add your contribution
Related Hubs
User Avatar
No comments yet.