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.

What is the Two's Complement Reference?

Two's complement reference and calculator: encode any signed decimal into its binary and hex bit pattern for 8, 16, 32 or 64-bit integers, decode it back, see overflow wrapping, and check signed and unsigned ranges per width. It runs free in your browser on Gera Tools, with nothing uploaded.

Two's Complement Reference

Name: Two's Complement Reference
Creator: Gera Tools
License: https://creativecommons.org/licenses/by/4.0/

Get one useful tool a week

Like this tool? Enter your email and we'll send you one genuinely useful Gera tool a week — plus a link to come back to this one. No spam, one-click 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.

This page is a reference companion to the converter — it explains the encoding rule, derives the key formulas, and covers the edge cases developers encounter.

Signed integer widths and their ranges

Width	Type name (C/Java)	Signed min	Signed max	Unsigned max
8-bit	`int8_t` / `byte`	−128	127	255
16-bit	`int16_t` / `short`	−32,768	32,767	65,535
32-bit	`int32_t` / `int`	−2,147,483,648	2,147,483,647	4,294,967,295
64-bit	`int64_t` / `long`	−9,223,372,036,854,775,808	9,223,372,036,854,775,807	18,446,744,073,709,551,615

The asymmetry (one more negative than positive) is structural: zero occupies one non-negative slot, leaving 2^(w−1) positives but 2^(w−1) negatives (which includes one extra). This is why INT_MIN has no positive counterpart — negating it overflows.

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.

Worked 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  ✓

The same 8 bits 0b11010110 mean 214 read as an unsigned uint8, or -42 read as a signed int8. The bits are identical; the interpretation differs.

Key properties and edge cases

Single zero: unlike sign-magnitude, two’s complement has exactly one representation of zero (0b000...0). This simplifies hardware.
Overflow wraps: adding 1 to the maximum positive value wraps to the minimum negative value. In C, signed overflow is undefined behaviour; in most hardware and in Java, it simply wraps. The tool shows the wrapped bit pattern for out-of-range inputs.
Sign extension: widening a signed integer (e.g. int8 to int32) copies the sign bit leftward — 0xFF (-1 as int8) becomes 0xFFFFFFFF (-1 as int32). Casting without sign extension would corrupt the value.
INT_MIN negation: negating INT_MIN overflows because its positive counterpart (2^(w−1)) is outside the range. In C, abs(INT_MIN) is undefined behaviour.