How does two's complement represent negative numbers?

A negative value n in a w-bit field is stored as the unsigned pattern 2^w + n. For example, -1 in 8 bits is 256 - 1 = 255 = 0b11111111. Decoding reverses this: if the top (sign) bit is 1, subtract 2^w from the unsigned reading to recover the signed value.

Why is the signed range asymmetric?

An 8-bit signed integer spans -128 to 127, one more negative value than positive. That is because zero takes one of the non-negative slots, leaving 127 positives but 128 negatives. This is why INT_MIN has no positive counterpart and negating it overflows.

What happens when a value is out of range?

It wraps around modulo 2^w — this is integer overflow. The tool flags out-of-range input and still shows the wrapped bit pattern, which is exactly what fixed-width hardware arithmetic would store. For 32-bit, 2147483647 + 1 wraps to -2147483648.

Why use two's complement instead of sign-magnitude?

Two's complement has a single representation of zero and lets the same adder hardware perform both signed and unsigned addition and subtraction without special cases. Sign-magnitude and one's complement both have a negative zero and need correction logic, so virtually all modern CPUs use two's complement.

Does this calculator handle 64-bit exactly?

Yes. It uses arbitrary-precision BigInt internally, so 64-bit values such as -9223372036854775808 are encoded and decoded exactly without the floating-point rounding that would corrupt large numbers in ordinary JavaScript numbers.

Two's Complement Reference

Email me this result

Get this tool's output sent to your inbox, plus one useful tool a week. No spam, unsubscribe any time.

Two’s complement is the standard way computers store signed integers. Almost every CPU, language and binary format uses it because it makes addition, subtraction and overflow behave uniformly. This tool encodes any signed decimal into its bit pattern, decodes it back, and shows the exact ranges for each common integer width.

How it works

For a w-bit integer, the top bit is the sign bit. A non-negative value is stored as its plain binary. A negative value n is stored as the unsigned pattern 2^w + n — equivalently, invert all bits of |n| and add 1.

Decoding reverses the rule: read the bits as an unsigned number u. If the sign bit is set, the signed value is u - 2^w; otherwise it is just u. The signed range is therefore -2^(w-1) to 2^(w-1) - 1.

Example

Encoding -42 in 8 bits:

|−42| = 42        = 0b0010_1010
invert            = 0b1101_0101
add 1             = 0b1101_0110 = 0xD6 = 214 unsigned
sign bit set → 214 − 256 = −42  ✓

Notes

The same bits read two ways: 0b11010110 is 214 as uint8 but -42 as int8. Casting between signed and unsigned just reinterprets the pattern.
Adding 1 to the maximum positive value wraps to the minimum negative value — classic signed overflow, which in C is undefined behavior but on hardware simply wraps.
Sign extension when widening (e.g. int8 → int32) copies the sign bit leftward so the value is preserved.
INT_MIN cannot be negated within the same width, because its positive counterpart is out of range.