Part Two:
An Introduction To Binary Numbers

Charles Brannon
Greensboro, NC

This is the second in a series of articles on elementary computer arithmetic. The previous article, Part One, described the binary numbering system, as used on a microcomputer. We will now delve into the use of binary numbers—adding and subtracting.

We'll start with the simplest one first—addition. Besides, you have to know how to add before you can subtract. As you might have realized, binary addition should be rather simple, since you are only adding ones and zeros. The few complications involve the carry. Just to refresh you on that, here is a sample base ten addition:

To add 23 and 51, we add the numbers digit by digit, from right to left. So first we add 3 and 1 to get 4, which we place underneath the digits added. Next we add the 2 and the 5, and place a 7 under those digits to get:

The carry comes in when we add two numbers and get a result too large to fit into a single digit, as in 6 + 8. In this case we have "four, carry the one," thus:

Notice that the carried one drops down into the next place in the number. If we were adding 16 and 8, the carry would be added to the 1 in 16, resulting in an answer of 24.

Now all of this is very elementary, but it demonstrates all the necessary actions to add in binary. Here is the "truth table" for addition in binary:

The first three additions are "common sense," but the final one, 1 + 1 = 10 deserves a second look. We know that one plus one equals two, but we're working in binary, so two is expressed as one-zero, or 10 This is also equivalent to "zero, carry the one" since "10" cannot fit in a single digit.

Let's run through a sample addition in binnary:

1. 1 + 1 = 0, carry the one
2. 0 + 1 = 1, plus carry of 1 gives 0, carry the one
3. 1 + 0 = 1, plus carry of 1 gives 0, carry the one
4. 0 + 1 = 1, plus carry of 1 gives 0, carry the one
5. 0 + 0 = 0, plus carry of 1 gives 1—no carry!

As always, since we are working with eight-bit bytes, we fill all unused digits with zeros. This is important.

As you can see, a single one can cause a whole string of carries, almost like a chain reaction. It is possible that the carry could be continued past the seventh bit (marked 8 above). Therefore, most microprocessors have a special register, called the carry bit to hold and signal this runaway bit. This bit is essential in adding multibyte numbers, which we will cover in Part Three. Let's try another addition.

This time we have an interesting effect of the carry. In step 5, we get 1 + 1=0, carry the one. In step 6, we add 1 + 1 + the carry of 1 to get 1, carry the one (1 + 1 + 1 = 11). The carry comes to rest at step 7. Incidentally, I have numbered the bits from 8 to 1 for convenience. In reality, they are numbered from 7 to 0, the exponents of the powers of two. (Bit 6=2⁶=64).

You now have the necessary information to add in binary, but in order for it to really "sink in," you will have to practice it until it becomes clear. You can make up your own exercises by randomly stringing a series of ones and zeros together to form two eight-digit numbers. Then add them in binary. To check your answer, convert the addends and the answer into decimal, which you can easily verify.

When you are confident that you can add in binary, you are ready to grasp this section on subtraction. When we perform subtraction in our normal, base ten system, we are really just adding the two numbers. For example, 8—5 is equivalent to 8+ (-5). -5 is pronounced "negative five." It is assumed that you are aware of negative numbers, as it is taught as early as sixth grade, but we all can forget, right? All that is necessary is to know that, when you add a negative and a positive number, you can get the same result as subtracting the smaller number from the larger number, and giving the answer the sign of the larger number. When you add two negative numbers, the answer is the same as adding the numbers, disregarding their sign (the absolute value), and then giving the sum a negative sign (e.g. (-4) + (-3) = -7). Yet believe it or not, subtraction in binary is even easier than in decimal, as a comparison will show.

First we have to know how a negative number is expressed in binary. Since a binary number is composed of ones and zeros, there is no place for the minus sign. Therefore, the highest bit, bit seven, is used to show that the number is negative. Most microcomputers use a technique called "two's complement" to convert a number into its negative equivalent. If you add numbers using two's complement, the subtraction will be performed automatically. Two's complement has two steps—forming the complement, and adding 1 to it. Numbers properly represented using two's complement are called signed binary.

Let's form the signed binary equivalent of -5. Here is the binary equivalent of five: 00000101. To complement it, we turn all the zeros into ones, and all the ones into zeros to get: 11111010. Next we add 1 to it to get:

Positive numbers in signed binary are expressed normally, with the restriction that they must not be greater than 127. If they were, bit seven would be "on," and the number would look as if it were negative. The number 205 in straight binary is 11001101. This is also -51 in signed binary. You can find the value of any negative number in signed binary by running it through the two's complement routine again. You'll get the positive value of the number. Similarly, if you try to make any number larger than 128 negative, it will end up positive. Therefore, in signed binary, the value in the byte must be between -128 and positive 127. Now that we have our background, let's try out our skills.

Notice that the carry was swept out of the byte (C:1). C: represents the imaginary carry register.

This carry should be always disregarded in two's complement subtraction. The most wonderful thing about subtraction in binary is that it is seemingly "automatic." But once again, for complete understanding, you must practice subtraction until you feel sure of your comprehension. For this purpose, exercises are once more included at the end of this article.

Next time, we'll learn about multibyte numbers and even get into a wee bit of MACHINE LANGUAGE!

Answers to exercises in PART ONE:

1. 1. 21
   2. 51
   3. 60
   4. 255
2. 1. 00110100
   2. 11101010
   3. 01000010
   4. 00001111
3. The complete chart to sixteen bits:

32768 16384 8192 4096 2048 1024
512 256 128 64 32 16 8 4 2 1

EXERCISES

1. Add:
   1. 00101011
      + 00000111
   2. 01000011
      + 00011000
   3. 00111000
      + 10100111
   4. 10011010
      + 00111001
2. Convert to binary and add:
   1. 20 + 11
   2. 18 + 56
   3. 29 + 47
   4. 32 + 64
3. Complement only:
   1. 01010110
   2. 01100011
4. Form the two's complement
   1. 01111001
   2. 10111111
5. convert into signed binary:
   1. -14
   2. 22
   3. -134
   4. 108
   5. -9
6. Convert to binary and subtract:
   1. 56-18
   2. 99-33
   3. 58-78
   4. -105-12
7. Why is -56 equal to 200? (Trick question)