Representing Signed Integers

The Need for Signed Numbers

You're already comfortable with unsigned binary numbers, where an n-bit number can represent values from 0 to $2^n-1$. However, to perform meaningful arithmetic, especially subtraction, we need a way to represent negative values. All signed number systems accomplish this by designating one bit, almost universally the most significant bit (MSB), as the sign bit.

A 0 in the MSB typically indicates a positive number, while a 1 indicates a negative number. The key difference between the methods we'll study lies in how they represent the magnitude of these negative numbers.

1. Sign-Magnitude Representation

The sign-magnitude format is the most straightforward and intuitive method. It mirrors how we write signed numbers in decimal: a sign followed by a magnitude.

• The MSB is the sign bit (0 for positive, 1 for negative).
• The remaining $n-1$ bits represent the absolute value (magnitude) of the number in standard binary.

To dive deeper into this representation, please watch the following video segment. It explains the concept and also touches upon why this simple method is not ideal for computer arithmetic.

As you saw in the video, sign-magnitude has two significant drawbacks:

1. Two Representations of Zero: In an 8-bit system, 00000000 represents +0, and 10000000 represents -0. This ambiguity complicates hardware design and requires special checks.
2. Complex Arithmetic: Performing addition and subtraction requires separate logic to handle the signs and magnitudes, making the hardware more complex than necessary. For example, to compute A - B, the circuit must compare the magnitudes of A and B to decide the sign of the result and whether to add or subtract the magnitudes.

Due to these issues, sign-magnitude representation is rarely used for integer arithmetic in modern CPUs.

2. Complement Representations: A Smarter Approach

To simplify arithmetic, particularly subtraction, digital systems use complement representations for negative numbers. The core idea is to make subtraction equivalent to addition, allowing the same adder circuit to be used for both operations. This is a crucial step towards designing an efficient ALU. We will explore two such methods.

One's (1's) Complement

In 1's complement form, positive numbers are represented the same way as in sign-magnitude. To represent a negative number, you simply invert every bit of its positive binary equivalent. This bit-flipping operation is also known as taking the complement.

Example: To find the 8-bit 1's complement representation of -45:

1. Start with the representation of +45: 00101101
2. Invert every bit: 11010010

So, 11010010 is the 1's complement representation of -45. Notice that the MSB automatically becomes 1, correctly indicating a negative number.

For a detailed explanation, including the mathematical definition and range, please watch the following video clip.

The main weakness of 1's complement, as highlighted in the video, is that it also has two representations of zero: 00000000 (+0) and 11111111 (-0). While it simplifies arithmetic compared to sign-magnitude, this ambiguity remains a problem. This leads us to the final and most important method.

3. Two's (2's) Complement

2's complement is the universal standard for representing signed integers in modern digital computers. It elegantly solves the problems of both sign-magnitude and 1's complement.

To find the 2's complement representation of a negative number, you first find the 1's complement and then add 1.

Example: To find the 8-bit 2's complement representation of -45:

1. Start with +45: 00101101
2. Find the 1's complement (invert all bits): 11010010
3. Add 1: 11010010 + 1 = 11010011

So, 11010011 is the 2's complement representation of -45.

The following video provides an excellent, comprehensive explanation of 2's complement, including two very useful shortcuts for finding it by hand.

Key Advantages of 2's Complement:

1. A Single, Unambiguous Zero: In an n-bit system, 0 is represented only as 00...0. If you try to take the 2's complement of 0, you get 0 back (with a carry bit that is discarded), eliminating the +0/-0 problem.
2. Simplified Arithmetic: Subtraction (A - B) is performed by simply adding the 2's complement of B to A: A + (2's comp of B). This means a single adder circuit can handle both addition and subtraction, drastically simplifying ALU design.
3. Asymmetric Range: An n-bit number can represent values from $-2^{n-1}$ to $+(2^{n-1}-1)$. For an 8-bit system, this is -128 to +127. There is one more negative number than positive numbers because there is no redundant "-0".

Summary and Comparison

The best way to solidify your understanding is to see these three representations side-by-side. The following resource provides a webpage with a clear summary and a very helpful comparison table.

Practice Problems

To master these concepts, let's work through a few problems. This will be essential for the next lesson on binary arithmetic.

1. Using an 8-bit system, find the binary representation of -29 in:
   a. Sign-Magnitude
   b. 1's Complement
   c. 2's Complement

2. What is the decimal value of the 8-bit binary number 11101000 if it is interpreted as:
   a. An unsigned integer?
   b. A sign-magnitude integer?
   c. A 1's complement integer?
   d. A 2's complement integer?

3. What is the range of decimal values that can be represented using a 16-bit 2's complement system?

Self-Correction and Reflection:

• For problem 1(c): After finding the 2's complement, try converting it back to a decimal value to check your work. A quick way is to note the MSB is 1, so it's a negative number. Take the 2's complement of your result; you should get the binary for +29.
• For problem 2: This problem highlights why context is everything. The same pattern of bits can represent four completely different numbers depending on the interpretation.

Conclusion

In this lesson, we have laid the crucial groundwork for understanding computer arithmetic. You've learned about the three primary methods for representing signed binary numbers and, most importantly, why 2's complement has become the industry standard.

Here are the key takeaways:

• Sign-Magnitude is intuitive but impractical for arithmetic due to its double-zero representation and complex hardware requirements.
• 1's Complement improves on arithmetic but retains the problematic double-zero.
• 2's Complement provides a single representation for zero and simplifies subtraction into addition, making it the most efficient method for hardware implementation.

This understanding is not just theoretical; it is the reason ALUs can be built so efficiently. In our next lesson, we will put this knowledge into practice by performing binary addition and subtraction using 2's complement arithmetic, a skill you will directly use when designing your ALU.