Two's Complement Calculator

A two's complement calculator converts a signed decimal number into the bit pattern a processor actually stores, and reads any bit pattern back as a signed value. Example: in 8 bits, −37 is 11011011, which is 0xDB in hex and 219 if the same byte is read as unsigned. One pattern, three legitimate readings.

Two sister tools cover the neighboring questions. The Binary Calculator converts and adds unsigned binary numbers when no negatives are involved, and the Hex Calculator handles hexadecimal arithmetic and hex-to-decimal conversion. Use this page whenever a minus sign, a fixed register width, or a wrap-around result is part of the problem.

What two's complement actually is

A computer register has a fixed number of columns. A byte has eight, a short has sixteen, a typical int has thirty-two. There is no extra place to keep a minus sign, so a convention is needed that lets the same adder circuit handle positive and negative values. Two's complement is that convention, and it is defined by one piece of arithmetic:

In words: to store a number you take it modulo 2 raised to the bit width, so −37 in a byte becomes 256 − 37 = 219, whose binary form is 11011011. To read a pattern back you use ordinary place values with one twist: the leftmost column counts as negative. In a byte that column is worth −128 instead of +128, and every other column keeps its usual weight of 64, 32, 16, 8, 4, 2 and 1.

The practical shortcut everyone learns is invert and add one, and it produces exactly the same answer as the modulo definition, because flipping all n bits of a number x gives 2ⁿ − 1 − x, and adding 1 gives 2ⁿ − x. That is the residue of −x. The shortcut is not a separate rule; it is the definition rearranged so it can be done by hand.

Worked example: −37 in an 8-bit register

Start with the magnitude and work down the three steps:

1. Write 37 in binary, padded to 8 bits: 37 = 32 + 4 + 1, so the pattern is 00100101.
2. Invert every bit: 11011010. As an unsigned number that is 218, and 218 = 255 − 37, exactly as the algebra predicts.
3. Add 1: 11011010 + 00000001 = 11011011, which is 219 unsigned and 0xDB in hexadecimal.

Check it with the weighted place values: the bits that are set sit in the −128, 64, 16, 8, 2 and 1 columns, and −128 + 64 + 16 + 8 + 2 + 1 = −37. Check it a second way by adding the pattern to +37: 11011011 + 00100101 = 100000000, and the ninth bit falls off the end of the byte, leaving 00000000. A number that adds to zero is the negative, which confirms the result.

All sixteen 4-bit patterns

Four bits are small enough to list completely, which makes the wrap-around obvious. The patterns run 0 to 7 on the positive side, then jump straight to −8 when the sign bit turns on, and count back up to −1 at all ones:

Two details are worth memorizing from this table. All ones is always −1, at every width. And the signed and unsigned readings of a negative pattern always differ by the full span: 1011 is −5 signed and 11 unsigned, and 11 − 16 = −5.

Ranges by bit width

The range is asymmetric at every width, because zero uses up one of the positive slots. The negative side always reaches exactly one further than the positive side:

The calculator above covers 4 through 32 bits. The 64-bit row is listed for reference because it is the width most database and language integer columns default to today.

Common byte values side by side

These are the patterns that show up constantly in memory dumps, protocol traces and debugger output. Every row is one byte read three ways:

Read down the last two columns and the rule becomes visible: for any negative signed value, unsigned = signed + 256 in a byte. The pattern 0xC8 is 200 to a network parser and −56 to a signed temperature reading, and nothing in the byte itself settles the argument.

Subtraction becomes addition

The reason hardware designers settled on two's complement is that it removes the special case for negative operands. To compute 5 − 9 in a byte, the processor forms the two's complement of 9 (00001001 inverted is 11110110, plus 1 is 11110111, which is −9 and 0xF7) and simply adds: 00000101 + 11110111 = 11111100. The sign bit is 1, so read it back by inverting and adding one: 00000011 + 1 = 00000100 = 4, therefore the value is −4. Correct, with one adder and no branch on the sign.

Overflow: when the answer will not fit

Because the width is fixed, some correct answers have nowhere to go. Add 100 and 50 in a byte: the true sum is 150, but the signed ceiling is 127. The bit-level addition 01100100 + 00110010 gives 10010110, and that pattern reads back as −106, because 150 − 256 = −106. Two positive inputs produced a negative output, which is exactly the hardware test for signed overflow: overflow occurred if the operands share a sign and the result carries the opposite one.

The mirror case is just as common. Adding −100 and −50 in a byte gives a true sum of −150, below the −128 floor, and the stored pattern 01101010 reads back as +106. Overflow is not an error the machine raises for you in most languages; it is a silent wrap. In C and C++ signed overflow is undefined behavior, so the compiler is free to assume it never happens, which is how optimizers occasionally delete an overflow check that a programmer wrote in good faith.

Sign extension when a value gets wider

Copying a signed byte into a 16-bit or 32-bit slot requires the new high bits to be filled with copies of the sign bit, not with zeros. The byte 11011011 (−37) becomes 1111111111011011 in 16 bits, which is 0xFFDB and still −37. Zero-filling instead would produce 0000000011011011, which is 219, a completely different number. This is the mechanism behind a whole family of bugs where a temperature, an offset or an audio sample turns into a large positive value the moment it is widened by the wrong instruction.

How to use this calculator

1. Pick the bit width that matches the register or data type you care about: 4 for classroom exercises, 8 for a byte, 16 for a short, 32 for a typical int. The signed range for the chosen width is printed underneath.
2. Choose the direction. "Decimal to binary" takes a signed number such as −37 and produces the stored pattern. "Binary to decimal" takes a pattern such as 11011011 and reports what it means as a signed value.
3. Type the value. Decimal accepts an optional minus sign; binary accepts 0s and 1s, with or without spaces, and is padded on the left to the full width.
4. Read the result card for all three readings at once: signed decimal, unsigned decimal and hexadecimal, plus the grouped bit pattern.
5. Follow the steps panel to see the magnitude, the inverted bits and the add-one result, which is what most homework and exams want you to show.
6. Test an addition in the bottom panel to see whether a sum stays inside the range or wraps, and by how much.

Who this calculator is for

• Computer science students working through a digital logic or computer architecture assignment that asks for the invert-and-add-one steps, not just the answer.
• Embedded and firmware developers decoding sensor registers, where a signed reading arrives as two bytes and the sign has to be reconstructed by hand.
• Reverse engineers and debuggers staring at a hex dump and trying to decide whether 0xFFDB is a small negative number or a large unsigned one.
• Protocol implementers checking that a field declared as int16 in a spec round-trips correctly through their encoder.
• Anyone chasing an overflow bug who needs to confirm that a mysterious −106 really is the wrapped form of 150.

Key terms

• Bit width: the number of columns in the register. It defines the range, the wrap point and the weight of the sign column.
• Sign bit (MSB): the leftmost bit. 1 means negative, 0 means zero or positive. It is a real place value, not a separate flag.
• One's complement: the intermediate result after flipping every bit, before the add-one step. It is also a historical signed format with two zeros.
• Wrap-around (modular arithmetic): the behavior that makes 127 + 1 land on −128 in a byte. The values form a circle, not a line.
• Sign extension: filling the new high bits with copies of the sign bit when a value is widened, so the number keeps its meaning.
• Signed vs unsigned: two interpretations of one pattern. Unsigned treats every column as positive; signed makes the leading column negative.
• Overflow: a result whose true value lies outside the representable range, so the stored answer is wrong by exactly one full span.

What changes the result

Only three things move the answer, and it is worth being deliberate about each:

• The bit width. The same decimal value produces a different pattern at every width, and the same pattern means different things depending on how wide the register is assumed to be. 1011 is −5 in four bits and +11 in eight.
• The sign convention. Reading a pattern as unsigned rather than two's complement shifts every negative value up by the full span, turning −1 into 255 in a byte.
• Whether the value fits. Anything outside the range silently wraps by a multiple of the span, so a range check has to happen before the conversion, not after.

Tips and quick checks

• Verify by adding. A pattern and its magnitude must add to all zeros inside the width. If they do not, a step went wrong.
• Use the shortcut for round numbers. The two's complement of a power of two is easy: −64 in a byte is 0xC0, −32 is 0xE0, −16 is 0xF0. Each halving adds another leading one.
• Copy from the right. A faster hand method than invert-and-add-one: copy bits from the right up to and including the first 1, then invert everything to the left of it. It gives the same pattern in one pass.
• Group bits in fours. Writing 1101 1011 instead of 11011011 makes the hex digits fall out immediately, since each group of four is one hex digit.
• Watch the extremes. The minimum value is its own negative: negating −128 in a byte gives −128 again, because +128 has no pattern.

Limitations and assumptions

• The tool covers integers only. Floating-point values use IEEE 754, which stores a sign bit, a biased exponent and a fraction, and does not use two's complement at all.
• Widths are limited to 4, 8, 16 and 32 bits. The same rules extend to 64 bits and beyond, but 64-bit values exceed the exact-integer range of standard browser arithmetic.
• It shows a single value in isolation, with no byte order. Whether a multi-byte value appears as DB FF or FF DB in memory depends on the platform's endianness.
• It models two's complement only, not sign-magnitude, one's complement, excess-K or binary-coded decimal, all of which appear in older or specialized hardware.
• Language rules differ. Java, C#, Go and Rust all define signed integers as two's complement with specified wrapping or trapping behavior, while C and C++ leave signed overflow undefined, so identical arithmetic can behave differently at the source level.

Which calculator to use when

If your numbers are never negative and you just need base conversion or plain binary arithmetic, the Binary Calculator is the simpler tool. If you are working from a hex dump and want hexadecimal arithmetic or a hex-to-decimal conversion without any sign question, use the Hex Calculator. When powers of two themselves are the question, such as how big 2 to the 31st is, the Exponent Calculator answers it directly. Come back to this page whenever a minus sign, a fixed register width or a suspicious wrap-around is involved.

Sources

Two's complement is a mathematical definition rather than a published rate or a policy figure, so no external source is required for the numbers on this page. Every pattern, range and worked example here follows directly from two exact statements: a value is stored as its residue modulo 2 raised to the bit width, and the leading column carries the weight −2 raised to (width − 1). The 4-bit table, the byte samples, the range table and the overflow examples were all computed from that definition and can be reproduced by hand with the invert-and-add-one procedure described above. The bit-width names used in the tables (byte, short, int, long) follow the fixed-width integer conventions of the ISO C standard's stdint types, which specify int8, int16, int32 and int64 as exactly-sized two's complement integers.