Hubbry Logo
Excess-3Excess-3Main
Open search
Excess-3
Community hub
Excess-3
logo
7 pages, 0 posts
0 subscribers
Be the first to start a discussion here.
Be the first to start a discussion here.
Contribute something
Excess-3
Excess-3
Excess-3
View on Wikipedia
from Wikipedia

Stibitz code
Digits4[1]
Tracks4[1]
Digit values8  4 −2 −1
Weight(s)1..3[1]
ContinuityNo[1]
CyclicNo[1]
Minimum distance1[1]
Maximum distance4
Redundancy0.7
Lexicography1[1]
Complement9[1]

Excess-3, 3-excess[1][2][3] or 10-excess-3 binary code (often abbreviated as XS-3,[4] 3XS[1] or X3[5][6]), shifted binary[7] or Stibitz code[1][2][8][9] (after George Stibitz,[10] who built a relay-based adding machine in 1937[11][12]) is a self-complementary binary-coded decimal (BCD) code and numeral system. It is a biased representation. Excess-3 code was used on some older computers as well as in cash registers and hand-held portable electronic calculators of the 1970s, among other uses.

Representation

[edit]

Biased codes are a way to represent values with a balanced number of positive and negative numbers using a pre-specified number N as a biasing value. Biased codes (and Gray codes) are non-weighted codes. In excess-3 code, numbers are represented as decimal digits, and each digit is represented by four bits as the digit value plus 3 (the "excess" amount):

  • The smallest binary number represents the smallest value (0 − excess).
  • The greatest binary number represents the largest value (2N+1 − excess − 1).
Excess-3, and Stibitz code
Decimal Excess-3 Stibitz BCD 8-4-2-1 Binary 3-of-6 CCITT
extension[13][1] 		4-of-8 Hamming
extension[1]
0 0011 0011 0000 0000 …10 …0011
1 0100 0100 0001 0001 …11 …1011
2 0101 0101 0010 0010 …10 …0101
3 0110 0110 0011 0011 …10 …0110
4 0111 0111 0100 0100 …00 …1000
5 1000 1000 0101 0101 …11 …0111
6 1001 1001 0110 0110 …10 …1001
7 1010 1010 0111 0111 …10 …1010
8 1011 1011 1000 1000 …00 …0100
9 1100 1100 1001 1001 …10 …1100

To encode a number such as 127, one simply encodes each of the decimal digits as above, giving (0100, 0101, 1010).

Excess-3 arithmetic uses different algorithms than normal non-biased BCD or binary positional system numbers. After adding two excess-3 digits, the raw sum is excess-6. For instance, after adding 1 (0100 in excess-3) and 2 (0101 in excess-3), the sum looks like 6 (1001 in excess-3) instead of 3 (0110 in excess-3). To correct this problem, after adding two digits, it is necessary to remove the extra bias by subtracting binary 0011 (decimal 3 in unbiased binary) if the resulting digit is less than decimal 10, or subtracting binary 1101 (decimal 13 in unbiased binary) if an overflow (carry) has occurred. (In 4-bit binary, subtracting binary 1101 is equivalent to adding 0011 and vice versa.)[14]

Advantage

[edit]

The primary advantage of excess-3 coding over non-biased coding is that a decimal number can be nines' complemented[1] (for subtraction) as easily as a binary number can be ones' complemented: just by inverting all bits.[1] Also, when the sum of two excess-3 digits is greater than 9, the carry bit of a 4-bit adder will be set high. This works because, after adding two digits, an "excess" value of 6 results in the sum. Because a 4-bit integer can only hold values 0 to 15, an excess of 6 means that any sum over 9 will overflow (produce a carry-out).

Another advantage is that the codes 0000 and 1111 are not used for any digit. A fault in a memory or basic transmission line may result in these codes. It is also more difficult to write the zero pattern to magnetic media.[1][15][11]

Example

[edit]

BCD 8-4-2-1 to excess-3 converter example in VHDL: 

entity bcd8421xs3 is
  port (
    a   : in    std_logic;
    b   : in    std_logic;
    c   : in    std_logic;
    d   : in    std_logic;

    an  : buffer std_logic;
    bn  : buffer std_logic;
    cn  : buffer std_logic;
    dn  : buffer std_logic;

    w   : out   std_logic;
    x   : out   std_logic;
    y   : out   std_logic;
    z   : out   std_logic
  );
end entity bcd8421xs3;

architecture dataflow of bcd8421xs3 is
begin
    an  <=  not a;
    bn  <=  not b;
    cn  <=  not c;
    dn  <=  not d;

    w   <=  (an and b  and d ) or (a  and bn and cn)
         or (an and b  and c  and dn);
    x   <=  (an and bn and d ) or (an and bn and c  and dn)
         or (an and b  and cn and dn) or (a  and bn and cn and d);
    y   <=  (an and cn and dn) or (an and c  and d )
         or (a  and bn and cn and dn);
    z   <=  (an and dn) or (a  and bn and cn and dn);

end architecture dataflow; -- of bcd8421xs3

Extensions

[edit]
3-of-6 extension
Digits6[1]
Tracks6[1]
Weight(s)3[1]
ContinuityNo[1]
CyclicNo[1]
Minimum distance2[1]
Maximum distance6
Lexicography1[1]
Complement(9)[1]
4-of-8 extension
Digits8[1]
Tracks8[1]
Weight(s)4[1]
ContinuityNo[1]
CyclicNo[1]
Minimum distance4[1]
Maximum distance8
Lexicography1[1]
Complement9[1]
  • 3-of-6 code extension: The excess-3 code is sometimes also used for data transfer, then often expanded to a 6-bit code per CCITT GT 43 No. 1, where 3 out of 6 bits are set.[13][1]
  • 4-of-8 code extension: As an alternative to the IBM transceiver code[16] (which is a 4-of-8 code with a Hamming distance of 2),[1] it is also possible to define a 4-of-8 excess-3 code extension achieving a Hamming distance of 4, if only denary digits are to be transferred.[1]

See also

[edit]

References

[edit]
Revisions and contributorsEdit on WikipediaRead on Wikipedia

Excess-3

View on Grokipedia
from Grokipedia
Excess-3 code, also known as XS-3 or Stibitz code (named after who developed it in the ), is a non-weighted (BCD) encoding scheme used to represent decimal digits 0 through 9, where each digit is encoded as a 4-bit binary value obtained by adding 3 (binary 0011) to its standard 8421 BCD equivalent. This results in a unique 4-bit pattern for each digit, ranging from 0011 for 0 to 1100 for 9, avoiding the all-zero representation present in standard BCD. The following table illustrates the Excess-3 encodings for decimal digits 0-9, alongside their BCD counterparts for comparison:
Decimal DigitBCD (8421)Excess-3 (XS-3)
000000011
100010100
200100101
300110110
401000111
501011000
601101001
701111010
810001011
910011100
A key property of Excess-3 code is that it is self-complementing, meaning the bitwise one's complement of the code for any digit d yields the code for (9 - d), which simplifies the computation of 9's complements in decimal subtraction without additional circuitry. This feature, along with reduced complexity in carry generation for addition and subtraction, made it advantageous for arithmetic operations in digital circuits. Excess-3 was used in early computing applications, such as in IBM 702, 705, 7080, and 1401 systems for decimal arithmetic, as well as in some relay-based computers and electronic calculators from the mid-20th century.

Introduction

Definition and Purpose

Excess-3 is a non-weighted (BCD) code that represents each decimal digit from 0 to 9 using a 4-bit binary value obtained by adding the binary equivalent of 3 (0011) to the standard BCD representation of that digit. This results in a biased encoding where the digit 0 is represented as 0011 and the digit 9 as 1100, ensuring all codes fall within the range of valid 4-bit values while avoiding the all-zero representation used for digit 0 in standard BCD. As part of the broader family of BCD codes, Excess-3 employs 4 bits per digit to enable binary hardware to process decimal numbers in a way that aligns with human-readable decimal notation, preserving the base-10 structure without requiring full binary conversion. Unlike weighted BCD variants such as 8421, Excess-3 does not assign positional weights to its bits, which contributes to its unique properties in digital encoding. The core purpose of Excess-3 is to facilitate arithmetic operations within -based digital systems by introducing a that simplifies complementation—particularly the 9's complement—for and enhances detection capabilities, all while maintaining compatibility with BCD frameworks. This self-complementing nature allows for efficient hardware implementation of decimal computations without the need for extensive handling or negative value representations.

Historical Context

Excess-3 code, a biased form of (BCD) representation, originated in the late at Bell Laboratories as an innovation in early digital computing. Developed by in collaboration with S. B. Williams and E. G. Andrews, and also known as Stibitz code, it was introduced to facilitate decimal arithmetic within binary relay-based systems, addressing challenges in handling complex calculations like those involving imaginary numbers. The code first appeared in the Complex Number Calculator (CNC), completed in November 1939, which used approximately 450 relays and represented numbers in an 8-digit BCD format with excess-3 encoding to simplify complement operations for . During the 1940s, Excess-3 became integral to subsequent relay computers, marking it as one of the earliest BCD variants employed in operational digital machines. The Model I (1940) and Model II (1943) incorporated the code alongside features like punched-tape programming and error-detecting mechanisms, enabling reliable decimal processing in electromechanical environments. These machines demonstrated key advancements, including the first remote computation over telephone lines in 1940, highlighting Excess-3's role in practical early computing applications. By the and , as electronic calculators and computers proliferated, Excess-3 emerged alongside other BCD codes to support decimal input/output compatibility in devices transitioning from electromechanical to solid-state designs. Excess-3 saw adoption in specialized hardware through the mid-, including some older computers and peripheral systems requiring precise decimal handling. In the 1970s, it appeared in cash registers and hand-held portable electronic calculators, where its self-complementing properties aided simple arithmetic without full binary conversion. However, its use declined with the widespread shift to pure binary in the late , as integrated circuits and microprocessors favored more efficient encodings like straight binary for higher performance and reduced complexity. Today, Excess-3 persists primarily in legacy systems, educational demonstrations of BCD principles, and niche historical recreations rather than mainstream .

Encoding and Representation

Binary Codes for Digits

Excess-3 code assigns a unique 4-bit binary representation to each decimal digit from 0 to 9 by adding a bias of 3 to the standard binary-coded decimal (BCD) value of the digit. This results in codes ranging from 0011 for digit 0 to 1100 for digit 9, with each code corresponding to the binary equivalent of the digit value plus 3. The bias ensures that the lowest three binary combinations (0000, 0001, 0010), which represent decimal values 0 through 2, are not used for valid digits, along with the highest three (1101, 1110, 1111), leaving six invalid states out of the 16 possible 4-bit patterns. The following table illustrates the Excess-3 encoding, showing the decimal digit, its standard 4-bit BCD (pure binary) value, the corresponding Excess-3 code, and the decimal equivalent of that code (which is always the digit plus 3):
Decimal DigitBinary Value (BCD)Excess-3 CodeDecimal Equivalent of Code
0000000113
1000101004
2001001015
3001101106
4010001117
5010110008
6011010019
70111101010
81000101111
91001110012

Conversion from and Binary

To encode a digit into Excess-3 , add 3 to the digit's value and represent the result as a 4-bit . For example, the digit 5 becomes 5 + 3 = 8, which in binary is 1000. This process applies to each digit individually in a multi-digit number, with the resulting 4-bit codes concatenated to form the full Excess-3 representation; for instance, the number 123 is encoded by processing 1 (1 + 3 = 4 = 0100), 2 (2 + 3 = 5 = 0101), and 3 (3 + 3 = 6 = 0110), yielding 010001010110. To decode an Excess-3 back to , convert each 4-bit group to its equivalent and subtract 3. For the example 1000, this yields 8 - 3 = 5. Valid Excess-3 codes for digits 0 through 9 range from 0011 to 1100; any 4-bit group outside this range, such as 0000 or 1111, is invalid and does not represent a valid digit. For multi-digit numbers, decoding proceeds digit by digit from left to right after separating the bit string into 4-bit groups. Since Excess-3 is a variant of (BCD), conversion from standard 8421 BCD (a 4-bit binary representation of each decimal digit) to Excess-3 involves adding the binary value 0011 (decimal 3) to each BCD digit group. For reference, the resulting Excess-3 codes match the fixed table provided in the Binary Codes for Digits section. The reverse conversion, from Excess-3 to 8421 BCD, subtracts 0011 from each group, ensuring the input falls within the valid range to avoid errors.

Properties and Characteristics

Advantages

One key advantage of the Excess-3 code is its self-complementing property, where the 9's complement of any decimal digit is obtained by simply inverting all bits (bitwise NOT) of its Excess-3 representation. For example, the Excess-3 code for 0 is 0011, and its bitwise complement 1100 represents 9; similarly, 0100 for 1 complements to 1011 for 8. This property arises because Excess-3 adds a of 3 to the standard BCD code, ensuring that the codes for digits d and 9-d are logical complements of each other. This self-complementing feature simplifies operations in decimal arithmetic by enabling efficient nines' complement methods without the need for complex digit-by-digit complement calculations. In contrast to standard BCD, where obtaining the 9's complement requires subtracting each digit from 9, Excess-3 allows to mimic binary one's complement by mere bit inversion, reducing hardware complexity and carry handling in complement-based arithmetic. This makes it particularly useful in early computing devices for performing as addition of the complement. Additionally, Excess-3 provides built-in error detection capabilities due to its six invalid 4-bit combinations (0000, 0001, 0010, 1101, 1110, 1111), which do not correspond to any valid digit. These unused states can be leveraged for validity checks or parity detection during data transmission or storage, flagging errors if an invalid code appears. This feature enhances reliability in digital systems handling data. The code also offers compatibility benefits in mixed binary-decimal environments, as conversion between Excess-3 and pure binary representations involves straightforward addition or subtraction of the bias (3 per digit), facilitating integration in systems requiring both formats.

Disadvantages and Limitations

Excess-3 code, as a form of binary-coded decimal (BCD) representation, utilizes four bits to encode each decimal digit from 0 to 9, resulting in lower storage density compared to pure binary encoding, which can represent larger numbers more efficiently using fewer bits overall for multi-digit values. This inefficiency arises because Excess-3 maps decimal digits to binary values from 0011 (3) to 1100 (12), leaving six of the sixteen possible four-bit combinations unused per digit, similar to standard BCD but without the density benefits of binary for computational storage. Implementing Excess-3 in hardware introduces added complexity, as encoding requires adding a of 3 to each BCD digit and decoding necessitates , demanding extra logic and circuits beyond those for straightforward BCD handling. These conversion operations increase overall circuit size and power consumption in digital systems, making Excess-3 less practical for efficient hardware compared to direct binary or simpler BCD variants. Due to the dominance of binary arithmetic in contemporary computing, Excess-3 has seen limited adoption and is largely obsolete outside of legacy applications. It remains relevant only in specific historical or educational contexts for decimal-based arithmetic, with modern systems favoring binary or ASCII-based decimal representations for greater compatibility and efficiency. As a non-weighted code, Excess-3 lacks assigned positional weights to its bits, which complicates direct interpretation and arithmetic operations without prior decoding, often requiring additional steps that offset its benefits in complementation. This structural limitation frequently leads to design challenges in systems needing straightforward bit-weighted calculations.

Arithmetic Operations

Addition in Excess-3

Addition in Excess-3 involves performing binary addition on the 4-bit Excess-3 encoded digits and applying a correction to account for the combined bias of 6 introduced by the encoding (3 from each operand). The 4-bit groups are added using a standard binary adder, producing a 4-bit sum and a possible carry-out. This carry-out is propagated to the next higher digit in multi-digit numbers. The correction step adjusts the 4-bit sum to the proper Excess-3 representation of the decimal digit sum (modulo 10), ensuring the bias is restored to 3 per digit. The correction rule is as follows: if the binary produces no carry-out (sum < 16), subtract 3 from the 4-bit result by adding (the 4-bit 2's complement of 3, equivalent to +13 16). If a carry-out is produced (sum ≥ 16), add 3 (0011 in binary) to the 4-bit result. This process yields the Excess-3 code for the sum digit while generating the appropriate carry (0 or 1) to the next digit. For digits including a carry-in from the previous position, the incorporates it, and the same correction logic applies, as the of Excess-3 adders handles the additional from the carry-in. The Excess-3 encoding minimizes long carry chains compared to standard BCD, as invalid intermediate sums are less likely to trigger extended ripples. In multi-digit addition, carries propagate normally from lower to higher digits. A carry-out from the most significant digit indicates overflow or the need for an additional higher digit. If the final corrected 4-bit result falls outside the valid Excess-3 range (0011 to 1100 binary), it indicates overflow or an invalid operation.

Subtraction Using Complements

Subtraction in Excess-3 code leverages the system's self-complementing , where the bitwise inversion (1's complement) of a digit's Excess-3 representation yields the Excess-3 code for the 9's complement of that digit. This simplifies the process of performing by converting it into an operation using complements, avoiding the need for dedicated subtraction circuitry or borrow propagation logic typical in direct binary . The method is particularly efficient in digital hardware, as it reuses circuits and requires only inverters for complement generation. The standard procedure for subtracting B from A (assuming A ≥ B and positive result) follows the 9's complement approach adapted to Excess-3:
  1. Represent both A and B in Excess-3 code, padding with digits if necessary for uniform length.
  2. For each digit of B, compute the 9's complement by bitwise NOT (inverting all four bits).
  3. Add this complemented B to A using binary , propagating carries across digits.
  4. If a carry is generated from the most significant digit, perform an end-around carry by adding 1 to the least significant digit of the sum.
  5. The resulting n-digit value represents the true decimal digits of (A - B) in ; convert each digit to Excess-3 by adding 0011 (3 in binary).
This works because the +3 in Excess-3 ensures that the inversion aligns precisely with the 9's complement representation: for a digit d, its Excess-3 code is (d + 3) in binary, and inverting bits gives 15 - (d + 3) = 12 - d, which is the Excess-3 code of (9 - d). When added to A's representation, the overall sum accounts for the biases, yielding (A - B + 9 × 10^k - 1) or equivalent after adjustments, with the end-around carry correcting the -1 offset. The final addition of 3 per digit restores the Excess-3 . Consider the example of subtracting 2 from 5 (single-digit for clarity; multi-digit follows similarly with propagation):
  • Excess-3 of 5: 1000 ( 8 in binary).
  • Excess-3 of 2: 0101 ( 5 in binary).
  • 9's complement of 2: bitwise NOT of 0101 = 1010 ( 10 in binary, Excess-3 of 7 = 9 - 2).
  • Add: 1000 + 1010 = 10010 (binary 18).
  • Carry out from the 4th bit: 1; low 4 bits: 0010 ( 2).
  • End-around carry: 0010 + 0001 = 0011 ( 3).
  • Convert to Excess-3: 0011 + 0011 = 0110 ( 6, Excess-3 of 3).
Verification: 5 - 2 = 3, Excess-3 of 3 is 0110. For multi-digit cases, such as 13 - 4 = 9, the process applies per digit with carry , resulting in the correct Excess-3 after adjustments, demonstrating reduced borrow handling as the complement mirrors regular Excess-3 without separate borrow flags.

Examples and Applications

Conversion Examples

To illustrate the encoding process in Excess-3 code, consider the decimal number 456. Each digit is individually increased by 3 and then converted to its 4-bit binary representation: 4 + 3 = 7 (0111), 5 + 3 = 8 (1000), and 6 + 3 = 9 (1001), resulting in the Excess-3 code 0111 1000 1001. For decoding, take the Excess-3 code 1010 0110 0110. Each 4-bit group is first interpreted as a value, then decreased by 3: 1010 represents 10, so 10 - 3 = 7; 0110 represents 6, so 6 - 3 = 3; and 0110 again yields 3. This decodes to the number 733. If any 4-bit group corresponds to a value outside the valid range (0 to 9 after subtraction, or 3 to 12 before), the code is invalid for standard Excess-3 representation. In multi-digit conversions, the process is applied sequentially to each digit before grouping into 4-bit binary segments, ensuring no carry-over between digits affects the encoding. For verification, the full 456 yields three 4-bit groups as shown, confirming the of +3 per digit without altering the overall structure. Edge cases highlight the bias effectively: the decimal 0 encodes as 0011 (0 + 3 = 3 in binary), while 9 encodes as 1100 (9 + 3 = 12 in binary), demonstrating how the code avoids all-zero representations and supports self-complementing properties.

Arithmetic Examples

To illustrate arithmetic operations in Excess-3 code, consider the of the numbers 123 and 456. First, encode each in Excess-3: 123 becomes 0100 0101 0110 (since 1+3=4=0100, 2+3=5=0101, 3+3=6=0110), and 456 becomes 0111 1000 1001 (4+3=7=0111, 5+3=8=1000, 6+3=9=1001). Perform binary addition digit by digit, propagating carries as needed. Starting from the units position: 0110 + 1001 = 1111 (binary value 15, no carry out since 15 < 16). For the tens position: 0101 + 1000 = 1101 (13, no carry out). For the hundreds position: 0100 + 0111 = 1011 (11, no carry out). The preliminary sum is thus 1011 1101 1111. Adjust each digit position based on whether it generated a carry out: since none did, subtract 0011 (3 in binary) from each 4-bit group. Units: 1111 - 0011 = 1100. Tens: 1101 - 0011 = 1010. Hundreds: 1011 - 0011 = 1000. The result is 1000 1010 1100, the Excess-3 encoding of 579 (decoded by subtracting 3 from each digit's binary value: 1000=8-3=5, 1010=10-3=7, 1100=12-3=9), confirming 123 + 456 = 579. Note that the units digits (Excess-3 for 3 and 6) summed to 1111 without carry out, requiring only the subtraction adjustment to yield 1100 (Excess-3 for 9). For subtraction, consider 579 - 123 using the 9's complement method, as Excess-3 is self-complementing (the bitwise NOT of a digit's code yields the Excess-3 for its 9's complement). The 9's complement of 123 is 876, encoded as 1011 1010 1001 (NOT of 0100=1011 for 8, NOT of 0101=1010 for 7, NOT of 0110=1001 for 6). Add this to 579's encoding 1000 1010 1100 using the Excess-3 procedure. Binary addition: Units 1100 + 1001 = 0101 (21 total, carry out 1). Tens: 1010 + 1010 + 1 (carry in) = 0101 (21, carry out 1). Hundreds: 1000 + 1011 + 1 = 0100 (20, carry out 1 to thousands). Preliminary sum: 0100 0101 0101 with thousands carry 1 (discard for now). Adjust: All positions generated carry outs, so add 0011 to each. Units: 0101 + 0011 = 1000. Tens: 0101 + 0011 = 1000. Hundreds: 0100 + 0011 = 0111. This yields 0111 1000 1000, the Excess-3 for (0111=7-3=4, 1000=8-3=5, 1000=8-3=5). Since 9's complement addition produces a result one less than the true difference when a thousands carry occurs, add 1 to the least significant digit: 1000 + 0001 = 1001 (no further carry). The adjusted result is 0111 1000 1001, Excess-3 for 456 (0111=4, 1000=5, 1001=9-3=6), confirming 579 - 123 = 456. To verify, decode all results: For the addition, 1000 1010 1100 subtracts 3 per digit to yield binary 0101 0110 1001 (5, 7, 9 in ). For , 0111 1000 1001 decodes to 0100 0111 1000 (4, 5, 6). These match the expected outcomes. Excess-3 arithmetic can detect certain errors, such as invalid sums. For instance, if yields a corrected digit of 0000 (Excess-3 for -3, which is invalid for non-negative digits 0-9), it signals an error like an overflow or incorrect input, as valid sums produce codes from 0011 (0) to 1100 (9).

Comparison to Other BCD Codes

Excess-3 code differs from the standard 8421 BCD in its fundamental design: it is a non-weighted code that adds a of 3 to each decimal digit's binary representation, whereas 8421 BCD is a weighted code with bit weights of 8, 4, 2, and 1, allowing direct arithmetic interpretation similar to pure binary but per digit. This in Excess-3 enables its self-complementing property, where the 1's complement of a yields the 9's complement of the original digit, simplifying via complement addition without additional circuitry for digit-wise adjustments, though it requires carry-based adjustments to account for the double in sums. Compared to Gray code BCD, which encodes each decimal digit to ensure only a single bit changes between consecutive values—reducing errors in applications like shaft encoders or mechanical switches—Excess-3 emphasizes arithmetic efficiency over error minimization, supporting straightforward complement-based operations at the expense of multiple bit transitions between digits. Unlike pure binary representation, which packs multiple decimal digits efficiently into variable-length bit strings requiring roughly 3.32 bits per digit on average, Excess-3—like other unpacked BCD variants—uses a fixed 4 bits per decimal digit to maintain direct compatibility with decimal input/output devices, incurring approximately 20% storage overhead for equivalent numerical ranges. These distinctions make Excess-3 particularly advantageous in subtraction-heavy tasks, such as early designs, while 8421 BCD serves as a more versatile option for general arithmetic due to its weighted structure and broader hardware support.

Extensions to Larger Numbers

To represent multi-digit numbers in Excess-3 code, each digit is independently encoded into its 4-bit Excess-3 representation and then concatenated to form the complete binary string, similar to other (BCD) formats. For example, the number 10 is encoded by representing 1 as 0100 (binary for 4, since 1 + 3 = 4) and 0 as 0011 (binary for 3, since 0 + 3 = 3), resulting in the 8-bit sequence 01000011. This approach allows straightforward extension to arbitrary-length numbers without additional encoding rules, maintaining the self-complementing property across digits for arithmetic operations. Arithmetic extensions of Excess-3 code apply its complement properties to multi-digit fixed-point representations, where the code facilitates efficient and by treating the entire number as a sequence of biased digits. In such systems, operands are converted to Excess-3 before processing, enabling scaled complement methods like 9's complementation for , which simplifies hardware implementation in arithmetic units. This was particularly useful in early electronic calculators, where Excess-3 supported fixed-point operations by simplifying carry handling in arithmetic units. Modern variants of Excess-3 code appear in reversible quantum computing circuits, where its bias enables efficient decimal arithmetic in quantum-dot cellular automata (QCA) and quantum reversible gates. For instance, quantum BCD-to-Excess-3 converters have been implemented using reversible logic to minimize quantum resource overhead, supporting addition of multi-digit numbers in fault-tolerant quantum environments. These adaptations leverage Excess-3's properties for low-power nano-scale designs and potential decimal processing in quantum systems, though practical deployments remain limited to research prototypes and legacy emulations.

References

  1. https://www.idc-online.com/technical_references/pdfs/electronic_engineering/Binary_Coded_Decimal.pdf
  2. https://www.ece.lsu.edu/alex/EE2720/EE2720_HO4.pdf
  3. https://ed-thelen.org/comp-hist/Reckoners-ch-4.html
  4. https://www.geeksforgeeks.org/digital-logic/excess-3-code/
  5. https://ee.usc.edu/~redekopp/ee101/slides/EE101Lecture2.pdf
  6. https://people.sabanciuniv.edu/erkays/cs303/ch01.pdf
  7. https://www.jmc.edu/econtent/pg/4781_UNIT%20II-DIGITAL%20LOGIC%20FUNDAMENDALS.pdf
  8. https://people.eecs.berkeley.edu/~newton/Classes/CS150sp98/quiz2sp98sol.pdf
  9. https://dspace.mit.edu/bitstream/handle/1721.1/116591/98890E.pdf?sequence=1&isAllowed=y
  10. https://ethw.org/George_R._Stibitz
  11. https://www.sciencedirect.com/science/article/abs/pii/B9780124916500500344
  12. https://mrecacademics.com/DepartmentStudyMaterials/20210515-DIGITAL%20ELECTRONICS.%20PDF.pdf
  13. http://hyperphysics.phy-astr.gsu.edu/hbase/Electronic/number3.html
  14. https://homepage.cs.uiowa.edu/~jones/ternary/bct.shtml
  15. https://courses.cs.umbc.edu/undergraduate/CMSC313/spring08/burt/lectures/CombinationalLogicDesign/
  16. http://www.ecpe.nu.ac.th/jirapornpook/courses/305131_2020/ch7_binary_code.pdf
  17. https://www.eeeguide.com/what-is-excess-3-code/
  18. https://pubs.aip.org/aip/acp/article-pdf/1444/1/310/12110199/310_1_online.pdf
  19. https://www.uomus.edu.iq/img/lectures21/MUCLecture_2024_13158746.pdf
  20. https://ieeexplore.ieee.org/document/10495820
  21. https://www.tutorialspoint.com/digital-electronics/bcd-to-excess-3-converter.htm
  22. https://www.sathyabama.ac.in/sites/default/files/course-material/2020-10/unit1_7.pdf
  23. https://www.ed-thelen.org/comp-hist/IBM_EngTrainingClass_1954/Ch4_DecimalCodes_Richards_1954.pdf
  24. https://www2.cs.uh.edu/~jhuang/JCH/LD/chap05.html
  25. https://athena.ecs.csus.edu/~dahlquid/eee174/S2005/Lecture10/174lecture10_files/bcd_representation_48.pdf
  26. https://www.researchgate.net/publication/314724180_Design_of_Digital_Arithmetic_Circuit_Using_Excess-3_Code_9%27S_Complement_Method
  27. https://ijarcce.com/upload/2017/march-17/IJARCCE%20142.pdf
  28. https://www.jsscacs.edu.in/sites/default/files/Department%20Files/Number%20System%20.pdf
  29. https://www.msuniv.ac.in/images/distance%20education/learning%20materials/ug%20pg/ug//bsc_physics/III%20Year%20-%20DJK3C%20-%20Digital%20Electronics.pdf
  30. https://www.electrical4u.com/excess-3-code-addition-subtraction/
  31. https://ece.uah.edu/~gaede/cpe422/05s_cpe422_hw7.pdf
  32. https://dl.acm.org/doi/pdf/10.1145/360569.360660
  33. http://arith.stanford.edu/~hfahmy/webpag_es/arith_class/arith2009_SilMinds.pdf
  34. https://ieeexplore.ieee.org/document/10134807/
  35. https://www.researchgate.net/publication/258570653_Reversible_Quantum_Computation_Using_Excess-3_Code
Add your contribution
Related Hubs
Contribute something
User Avatar
No comments yet.