Two's complement is the most common method of representing signed (positive, negative, and zero) integers on computers,^[1] and more generally, fixed point binary values. Two's complement uses the binary digit with the greatest place value as the sign to indicate whether the binary number is positive or negative. When the most significant bit is 1, the number is signed as negative; and when the most significant bit is 0 the number is signed as positive.

Unlike the ones' complement scheme, the two's complement scheme has only one representation for zero. Furthermore, arithmetic implementations can be used on signed as well as unsigned integers^[2] and differ only in the integer overflow situations.

Procedure

The two's complement of an integer is computed by:

• Step 1: starting with the binary representation of the number, with the leading bit being a sign bit;
• Step 2: inverting (or flipping) all bits – changing every 0 to 1, and every 1 to 0;
• Step 3: adding 1 to the entire inverted number, ignoring any overflow. Accounting for overflow will produce the wrong value for the result.

For example, to calculate the decimal number −6 in binary from the number 6:

• Step 1: +6 in decimal is 0110 in binary; the leftmost significant bit (the first 0) is the sign (just 110 in binary would be -2 in decimal).
• Step 2: flip all bits in 0110, giving 1001.
• Step 3: add the place value 1 to the flipped number 1001, giving 1010.

To verify that 1010 indeed has a value of −6, add the place values together, but subtract the sign value from the final calculation. Because the most significant value is the sign value, it must be subtracted to produce the correct result: 1010 = −(1×2³) + (0×2²) + (1×2¹) + (0×2⁰) = 1×−8 + 0 + 1×2 + 0 = −6.

Note that steps 2 and 3 together are a valid method to compute the additive inverse ${\displaystyle -n}$ of any (positive or negative) integer ${\displaystyle n}$ where both input and output are in two's complement format. An alternative to compute ${\displaystyle -n}$ is to use subtraction ${\displaystyle 0-n}$. See below for subtraction of integers in two's complement format.

Theory

Two's complement is an example of a radix complement. The 'two' in the name refers to the term which, expanded fully in an N-bit system, is actually "two to the power of N" - 2^N (the only case where exactly 'two' would be produced in this term is N = 1, so for a 1-bit system, but these do not have capacity for both a sign and a zero), and it is only this full term in respect to which the complement is calculated. As such, the precise definition of the Two's complement of an N-bit number is the complement of that number with respect to 2^N.

The defining property of being a complement to a number with respect to 2^N is simply that the summation of this number with the original produce 2^N. For example, using binary with numbers up to three-bits (so N = 3 and 2^N = 2³ = 8 = 1000₂, where '₂' indicates a binary representation), a two's complement for the number 3 (011₂) is 5 (101₂), because summed to the original it gives 2³ = 1000₂ = 011₂ + 101₂. Where this correspondence is employed for representing negative numbers, it effectively means, using an analogy with decimal digits and a number-space only allowing eight non-negative numbers 0 through 7, dividing the number-space in two sets: the first four of the numbers 0 1 2 3 remain the same, while the remaining four encode negative numbers, maintaining their growing order, so making 4 encode -4, 5 encode -3, 6 encode -2 and 7 encode -1. A binary representation has an additional utility however, because the most significant bit also indicates the group (and the sign): it is 0 for the first group of non-negatives, and 1 for the second group of negatives. The tables at right illustrate this property.

Calculation of the binary two's complement of a positive number essentially means subtracting the number from the 2^N. But as can be seen for the three-bit example and the four-bit 1000₂ (2³), the number 2^N will not itself be representable in a system limited to N bits, as it is just outside the N bits space (the number is nevertheless the reference point of the "Two's complement" in an N-bit system). Because of this, systems with maximally N-bits must break the subtraction into two operations: first subtract from the maximum number in the N-bit system, that is 2^N-1 (this term in binary is actually a simple number consisting of 'all 1s', and a subtraction from it can be done simply by inverting all bits in the number also known as the bitwise NOT operation) and then adding the one. Coincidentally, that intermediate number before adding the one is also used in computer science as another method of signed number representation and is called a Ones' complement (named that because summing such a number with the original gives the 'all 1s').

Compared to other systems for representing signed numbers (e.g., ones' complement), the two's complement has the advantage that the fundamental arithmetic operations of addition, subtraction, and multiplication are identical to those for unsigned binary numbers (as long as the inputs are represented in the same number of bits as the output, and any overflow beyond those bits is discarded from the result). This property makes the system simpler to implement, especially for higher-precision arithmetic. Additionally, unlike ones' complement systems, two's complement has no representation for negative zero, and thus does not suffer from its associated difficulties. Otherwise, both schemes have the desired property that the sign of integers can be reversed by taking the complement of its binary representation, but two's complement has an exception - the lowest negative, as can be seen in the tables.^[3]

History

The method of complements had long been used to perform subtraction in decimal adding machines and mechanical calculators. John von Neumann suggested use of two's complement binary representation in his 1945 First Draft of a Report on the EDVAC proposal for an electronic stored-program digital computer.^[4] The 1949 EDSAC, which was inspired by the First Draft, used two's complement representation of negative binary integers.

Many early computers, including the CDC 6600, the LINC, the PDP-1, and the UNIVAC 1107, use ones' complement notation; the descendants of the UNIVAC 1107, the UNIVAC 1100/2200 series, continued to do so. The IBM 700/7000 series scientific machines use sign/magnitude notation, except for the index registers which are two's complement. Early commercial computers storing negative values in two's complement form include the English Electric DEUCE (1955) and the Digital Equipment Corporation PDP-5 (1963) and PDP-6 (1964). The System/360, introduced in 1964 by IBM, then the dominant player in the computer industry, made two's complement the most widely used binary representation in the computer industry. The first minicomputer, the PDP-8 introduced in 1965, uses two's complement arithmetic, as do the 1969 Data General Nova, the 1970 PDP-11, and almost all subsequent minicomputers and microcomputers.

Converting from two's complement representation

A two's-complement number system encodes positive and negative numbers in a binary number representation. The weight of each bit is a power of two, except for the most significant bit, whose weight is the negative of the corresponding power of two.

The value w of an N-bit integer ${\displaystyle a_{N-1}a_{N-2}\dots a_{0}}$ is given by the following formula:

${\displaystyle w=-a_{N-1}2^{N-1}+\sum _{i=0}^{N-2}a_{i}2^{i}}$

The most significant bit determines the sign of the number and is sometimes called the sign bit. Unlike in sign-and-magnitude representation, the sign bit also has the weight −(2^N − 1) shown above. Using N bits, all integers from −(2^N − 1) to 2^N − 1 − 1 can be represented.

Converting to two's complement representation

In two's complement notation, a non-negative number is represented by its ordinary binary representation; in this case, the most significant bit is 0. Though, the range of numbers represented is not the same as with unsigned binary numbers. For example, an 8-bit unsigned number can represent the values 0 to 255 (11111111). However a two's complement 8-bit number can only represent non-negative integers from 0 to 127 (01111111), because the rest of the bit combinations with the most significant bit as '1' represent the negative integers −1 to −128.

The two's complement operation is the additive inverse operation, so negative numbers are represented by the two's complement of the absolute value.

Sign extension

When turning a two's-complement number with a certain number of bits into one with more bits (e.g., when copying from a one-byte variable to a two-byte variable), the most-significant bit must be repeated in all the extra bits. Some processors do this in a single instruction; on other processors, a conditional must be used followed by code to set the relevant bits or bytes.

Similarly, when a number is shifted to the right, the most-significant bit, which contains the sign information, must be maintained. However, when shifted to the left, a bit is shifted out. These rules preserve the common semantics that left shifts multiply the number by two and right shifts divide the number by two. However, if the most-significant bit changes from 0 to 1 (and vice versa), overflow is said to occur in the case that the value represents a signed integer.

Both shifting and doubling the precision are important for some multiplication algorithms. Note that unlike addition and subtraction, width extension and right shifting are done differently for signed and unsigned numbers.

Most negative number

With only one exception, starting with any number in two's-complement representation, if all the bits are flipped and 1 added, the two's-complement representation of the negative of that number is obtained. Positive 12 becomes negative 12, positive 5 becomes negative 5, zero becomes zero(+overflow), etc.

Taking the two's complement (negation) of the minimum number in the range will not have the desired effect of negating the number. For example, the two's complement of −128 in an eight-bit system is −128 , as shown in the table to the right. Although the expected result from negating −128 is +128 , there is no representation of +128 with an eight bit two's complement system and thus it is in fact impossible to represent the negation. Note that the two's complement being the same number is detected as an overflow condition since there was a carry into but not out of the most-significant bit.

Having a nonzero number equal to its own negation is forced by the fact that zero is its own negation, and that the total number of numbers is even. Proof: there are 2^n - 1 nonzero numbers (an odd number). Negation would partition the nonzero numbers into sets of size 2, but this would result in the set of nonzero numbers having even cardinality. So at least one of the sets has size 1, i.e., a nonzero number is its own negation.

The presence of the most negative number can lead to unexpected programming bugs where the result has an unexpected sign, or leads to an unexpected overflow exception, or leads to completely strange behaviors. For example,

• the unary negation operator may not change the sign of a nonzero number. e.g., −(−128)  ⟼  −128   (where "⟼" is read as "becomes").
• an implementation of absolute value may return a negative number;^[5] e.g.,   abs(−128)  ⟼  −128 .

• Likewise, multiplication by −1 may fail to function as expected; e.g.,   (−128) × (−1)  ⟼  −128 .
• Division by −1 may cause an exception (like that caused by dividing by 0 );^[6] even calculating the remainder (or modulo) by −1 can trigger this exception;^[7] e.g., (−128) ÷ (−1)  ⟼  [CRASH] ,   (−128) % (−1)  ⟼  [CRASH] .

In the C and C++ programming languages, the above behaviours are undefined and not only may they return strange results, but the compiler is free to assume that the programmer has ensured that undefined numerical operations never happen, and make inferences from that assumption.^[7] This enables a number of optimizations, but also leads to a number of strange bugs in programs with these undefined calculations.

This most negative number in two's complement is sometimes called "the weird number", because it is the only exception.^[8][9] Although the number is an exception, it is a valid number in regular two's complement systems. All arithmetic operations work with it both as an operand and (unless there was an overflow) a result.

Why it works

Given a set of all possible N-bit values, we can assign the lower (by the binary value) half to be the integers from 0 to (2^N − 1 − 1) inclusive and the upper half to be −2^N − 1 to −1 inclusive. The upper half (again, by the binary value) can be used to represent negative integers from −2^N − 1 to −1 because, under addition modulo 2^N they behave the same way as those negative integers. That is to say that because i + j mod 2^N = i + (j + 2^N) mod 2^N any value in the set { j + k 2^N | k is an integer }  can be used in place of j.^[10]

For example, with eight bits, the unsigned bytes are 0 to 255. Subtracting 256 from the top half (128 to 255) yields the signed bytes −128 to −1.

The relationship to two's complement is realised by noting that 256 = 255 + 1, and (255 − x) is the ones' complement of x.

   1111 1111                       255.
 − 0101 1111                     −  95.
 ===========                     =====
   1010 0000  (ones' complement)   160.
 +         1                     +   1
 ===========                     =====
   1010 0001  (two's complement)   161.

Arithmetic operations

   0000 1111  (15)
 + 1111 1011  (−5)
 ===========
   0000 1010  (10)

   0000 0101  (  5)
 + 1111 0001  (−15)
 ===========
   1111 0110  (−10)

  0111   (carry)
   0111  (7)
 + 0011  (3)
 ======
   1010  (−6)  invalid!

  11110 000   (borrow)
   0000 1111  (15)
 − 1111 1011  (−5)
 ===========
   0001 0100  (20)

  11100 000   (borrow)
   0000 1111  (15)
 − 0010 0011  (35)
 ===========
   1110 1100  (−20)

     00000110  (6)
 *   11111011  (−5)
 ============
          110
         1100
        00000
       110000
      1100000
     11000000
    x10000000
 + xx00000000
 ============
   xx11100010

  0 0110  (6)  (multiplicand with extended sign bit)
  × 1011 (−5)  (multiplier)
  =|====|====
  0|0110|0000  (first partial product (rightmost bit is 1))
  0|0011|0000  (shift right, preserving extended sign bit)
  0|1001|0000  (add second partial product (next bit is 1))
  0|0100|1000  (shift right, preserving extended sign bit)
  0|0100|1000  (add third partial product: 0 so no change)
  0|0010|0100  (shift right, preserving extended sign bit)
  1|1100|0100  (subtract last partial product since it's from sign bit)
  1|1110|0010  (shift right, preserving extended sign bit)
   |1110|0010  (discard extended sign bit, giving the final answer, −30)

// reversed comparison of the sign bit

if A(n-1) == 0 and B(n-1) == 1 then
    return +1
else if A(n-1) == 1 and B(n-1) == 0 then
    return -1
end
 
// comparison of remaining bits

for i = n-2...0 do
    if A(i) == 0 and B(i) == 1 then
        return -1
    else if A(i) == 1 and B(i) == 0 then
        return +1 
    end
end
 
return 0

Two's complement and 2-adic numbers

In a classic HAKMEM published by the MIT AI Lab in 1972, Bill Gosper noted that whether or not a machine's internal representation was two's-complement could be determined by summing the successive powers of two. In a flight of fancy, he noted that the result of doing this algebraically indicated that "algebra is run on a machine (the universe) which is two's-complement."^[15]

Gosper's end conclusion is not necessarily meant to be taken seriously, and it is akin to a mathematical joke. The critical step is "...110 = ...111 − 1", i.e., "2X = X − 1", and thus X = ...111 = −1. This presupposes a method by which an infinite string of 1s is considered a number, which requires an extension of the finite place-value concepts in elementary arithmetic. It is meaningful either as part of a two's-complement notation for all integers, as a typical 2-adic number, or even as one of the generalized sums defined for the divergent series of real numbers 1 + 2 + 4 + 8 + ···.^[16] Digital arithmetic circuits, idealized to operate with infinite (extending to positive powers of 2) bit strings, produce 2-adic addition and multiplication compatible with two's complement representation.^[17] Continuity of binary arithmetical and bitwise operations in 2-adic metric also has some use in cryptography.^[18]

Fraction conversion

To convert a number with a fractional part, such as .0101, one must convert starting from right to left the 1s to decimal as in a normal conversion. In this example 0101 is equal to 5 in decimal. Each digit after the floating point represents a fraction where the denominator is a multiplier of 2. So, the first is 1/2, the second is 1/4 and so on. Having already calculated the decimal value as mentioned above, only the denominator of the LSB (LSB = starting from right) is used. The final result of this conversion is 5/16.

For instance, having the floating value of .0110 for this method to work, one should not consider the last 0 from the right. Hence, instead of calculating the decimal value for 0110, we calculate the value 011, which is 3 in decimal (by leaving the 0 in the end, the result would have been 6, together with the denominator 2⁴ = 16, which reduces to 3/8). The denominator is 8, giving a final result of 3/8.

See also

• Ones' complement, an alternative binary number convention
• Division algorithm, including restoring and non-restoring division in two's-complement representations
• Offset binary
• p-adic number
• Method of complements, generalisation to other number bases, used on mechanical calculators

Notes

References

Further reading

• Two's Complement Explanation, (Thomas Finley, 2000)
• Koren, Israel (2002). Computer Arithmetic Algorithms. A.K. Peters. ISBN 1-56881-160-8.
• Flores, Ivan (1963). The Logic of Computer Arithmetic. Prentice-Hall.

External links

• Two's complement array multiplier JavaScript simulator