Two's Complement Converter

Two’s complement is ordinary positional notation with one change: the most significant column’s weight is negative. At eight bits the place values read −128, 64, 32, 16, 8, 4, 2, 1, so 11010011 is −128 + 64 + 16 + 2 + 1 = −45. That is the definition, and every other rule on this page follows from it.

The familiar “invert the bits and add one” procedure is a consequence, not the definition. Inverting a w-bit pattern turns x into 2^w − 1 − x, and adding one turns that into 2^w − x, which is exactly the pattern whose negative-weighted sum is −x.

Write the magnitude, invert every bit, add one. For −45 at eight bits: 45 is 00101101; inverted it is 11010010; plus one it is 11010011.

The by-hand shortcut gives the same answer with no addition: copy bits from the right up to and including the first 1, then invert everything to the left. 00101101 → keep the final 1, invert 0010110 → 1101001 → 11010011.

Courses teach two methods and both are correct, so both are shown here.

• Weighted sum. Add the place values of the set bits with the most significant one negative: −128 + 64 + 16 + 2 + 1 = −45.
• Negate and read. If the most significant bit is 1, apply invert and add one to get the magnitude, then attach the minus sign: 11010011 → 00101101 = 45, so the value is −45.

A two’s-complement value is meaningless without a width. 1011 is −5 in 4 bits and 11 in 8 bits. At w bits the signed range is −2^(w−1) to 2^(w−1)−1 and the unsigned range is 0 to 2^w−1.

Widening a signed value copies the sign bit into the new positions. 1011 at 4 bits is −5; sign-extended to 8 bits it is 11111011, still −5. Zero-extending it instead gives 00001011 = +11, which is correct only if the value was unsigned. For a positive source the two agree: 0110 becomes 00000110 = 6 either way.

Truncation preserves the value only if every discarded bit equals the sign bit that remains. 11111011 (−5) narrowed to four bits is 1011 = −5, which is safe. 11110110 (−10) narrowed to four bits is 0110 = +6, which is not.

Signed overflow has two equivalent tests. It occurs exactly when the carry into the most significant column differs from the carry outof it — that is, V = c_w ⊕ c_(w−1). Equivalently, it occurs when both operands have the same sign and the result’s sign differs from theirs.

The classic exam pair, both at eight bits: 0x7F + 0x01 = 0x80 sets V = 1 with C = 0 — overflow without a carry — while 0xFF + 0x01 = 0x00 sets C = 1 with V = 0 — a carry without overflow. The full ripple, with both flags on every result, is on the binary arithmetic page.

At eight bits 10000000 is −128. Invert it and you get 01111111; add one and you are back at 10000000. −128 has no positive counterpart in eight bits, so negating it returns itself. This is the one asymmetry of two’s complement and it is the reason abs(INT_MIN) overflows in C, Java, C# and Rust.

Three conventions for signed binary were in use, and two of them lost for the same two reasons: they have two representations of zero, and their adders need a correction step.

Two’s complement is for integers. Non-integers use IEEE 754, which stores a sign bit, a biased exponent and a significand instead of place values. −118.625 as binary32 is 0xC2ED4000: the sign bit is 1, the biased exponent 10000101₂ is 133, so e = 133 − 127 = 6, and 1.110110101₂ × 2⁶ is −118.625. The standard is IEEE 754-2019 (opens in a new tab).

• The most significant bit is leftmost; bits are 0-indexed from the least significant end.
• The most significant bit is called the sign bit, but it is a value bit with weight −2^(w−1), not a separate flag.
• Hexadecimal output is upper case with no 0x prefix inside the bit strip.
• Two’s complement has exactly one zero, so −0 is normalised to 0.

Two’s complement has no single canonical citation and is stated here as the standard result it is. The one external standard cited is IEEE 754-2019, IEEE Standard for Floating-Point Arithmetic (opens in a new tab), in the floating-point section above.