Two's Complement Arithmetic

1. The Need for a Better System: Why Two's Complement?

Before we learn how two's complement works, it's crucial to understand why it's the universal standard. The most intuitive way to represent a negative number, called sign-magnitude, simply flips a "sign bit" (e.g., the most significant bit, MSB). However, this simple approach leads to two representations for zero (+0 and -0) and breaks standard binary addition.

To see why these simpler methods are flawed and why two's complement is superior, let's watch a fantastic conceptual explanation.

The key takeaway is that two's complement allows us to perform both addition and subtraction using the exact same hardware logic—an adder. This is a massive efficiency gain in circuit design. Subtracting a number B from A simply becomes adding the two's complement of B to A.

2. How to Create a Two's Complement Number

The method for finding the two's complement of a number (i.e., negating it) is a two-step process:

1. Invert all the bits: Change every 0 to a 1 and every 1 to a 0. This is called the one's complement.
2. Add 1 to the result.

Let's look at a visual representation of this process.

For example, let's find the 8-bit two's complement representation of -42:

1. Start with the positive decimal number: 42.
2. Convert to 8-bit binary: 00101010.
3. Invert the bits (one's complement): 11010101.
4. Add 1:

     11010101
   +        1
   -----------
     11010110 
   

So, -42 in 8-bit two's complement is 11010110.

A useful shortcut to know: starting from the right (least significant bit), copy all bits until you copy your first 1. Then, invert all the bits to the left of that.

3. Binary Arithmetic with Two's Complement

Now let's put this into practice. The beauty of two's complement is that addition works the same way regardless of whether the numbers are positive or negative. You just add them as if they were unsigned, and the result is correct, provided it doesn't go out of range.

The following video provides excellent, step-by-step examples of different arithmetic scenarios. We will go through it in parts.

Case 1: Adding a Positive and a Negative Number

This is the most direct application, where subtraction is turned into addition.

• A - B is the same as A + (-B).
• We find the two's complement of B and add it to A.
• Any carry-out bit from the most significant position is simply discarded.

Case 2: Subtraction

Subtraction A - B is handled by converting it to A + (-B). This means we take the two's complement of the number being subtracted (the subtrahend) and add it to the other number (the minuend).

Practice Exercise 1:
Calculate 11 - 5 using 5-bit two's complement arithmetic.

4. The Problem of Overflow

What happens if the result of a calculation is too large (or too small) to be represented with the available number of bits? This is called overflow, and it produces an incorrect result.

For an n-bit signed number, the representable range is from $-2^{n-1}$ to $+2^{n-1}-1$.

• For 5 bits, the range is -16 to +15.
• For 8 bits, the range is -128 to +127.

Overflow Rule: In two's complement, overflow can only happen when adding two numbers of the same sign.

• Positive + Positive = Negative Result -> OVERFLOW
• Negative + Negative = Positive Result -> OVERFLOW

Overflow is impossible when adding a positive and a negative number.

Let's see this in action.

The concept of overflow is extremely important in hardware design. If you define a register in Verilog to be 8 bits wide but the result of an addition needs 9 bits, you will get an overflow and a silent, incorrect result unless you design your logic to detect it.

Practice Exercise 2:
Calculate 9 + 8 using 5-bit two's complement arithmetic and determine if overflow occurs.

Conclusion

Great job working through these concepts. You now understand not just how to perform binary arithmetic, but also the fundamental principles that make it efficient in hardware.

Here are the key takeaways from this lesson:

• Two's complement is the standard for representing signed integers because it avoids the issues of other systems and allows a single adder circuit to perform both addition and subtraction.
• To negate a number, you invert all bits and add 1.
• Subtraction A - B is performed as A + (-B), where -B is the two's complement of B.
• Overflow is an error that occurs when the result of an arithmetic operation exceeds the bit-width's representable range. It can be detected when adding two numbers of the same sign yields a result with the opposite sign.

In our next lesson, we'll shift gears from number representation to logic itself. We will explore Boolean algebra, the mathematical foundation upon which all digital logic circuits are built. This will equip us to start designing the simple circuits that perform these very arithmetic operations.