Home > Articles > Programming > General Programming/Other Languages

  • Print
  • + Share This
This chapter is from the book

Binary Arithmetic

At their lowest level, computers cannot subtract, multiply, or divide. Neither can calculators. The world's largest and fastest supercomputer can only add—that's it. It performs the addition at the bit level. Binary arithmetic is the only means by which any electronic digital computing machine can perform arithmetic.

Suppose you want the computer to add seven 6s together. If you asked the computer (through programming) to perform the calculation

6 + 6 + 6 + 6 + 6 + 6 + 6

the computer would zing the answer, 42, back to you before you could say bit bucket. The computer has no problem performing addition. The problems arise when you request that the computer perform another type of calculation, such as this one:

42 – 6 – 6 – 6 – 6 – 6 – 6 – 6

Because the computer can only add, it cannot do the subtraction. However, the computer can negate numbers. That is, the computer can take the negative of a number. Therefore, it can take the negative of 6 and represent (at the bit level) negative 6. Once it has done that, it can add –6 to 42 seven times. In effect, the internal calculation becomes this:

42 + (–6) + (–6) + (–6) + (–6) + (–6) + (–6) + (–6)

Adding seven –6s produces the correct result of 0. This may seem like a cop-out to you. After all, the computer is really subtracting, right? In reality, the computer is not subtracting. At its bit level, the computer can convert a number to its negative through a process known as 2's complement. A number's 2's complement is the negative of its original value at the bit level. The computer has in its internal logic circuits the capability to convert a number to its 2's complement and then carry out the addition of negatives, thereby seemingly performing subtraction.

Once the computer can add and simulate subtraction, it can simulate multiplying and dividing. To multiply 6 times 7, the computer actually adds 6 together seven times and produces 42. Therefore

6 x 7

becomes this:

6 + 6 + 6 + 6 + 6 + 6 + 6

To divide 42 by 7, the computer subtracts 7 from 42 (well, it adds the negative of 7 to 42) until it reaches zero and counts the number of times (6) it took to reach zero, like this:

42 + (–7) + (–7) + (–7) + (–7) + (–7) + (–7)

The computer represents numbers in a manner similar to characters. As Table 3.2 shows, numbers are easy to represent at the binary level. Once numbers reach a certain limit (256 to be exact), the computer will use more than one byte to represent the number, taking as many memory locations as it needs to represent the number. After it is taught to add, subtract, multiply, and divide, the computer can then perform any math necessary as long as a program is supplied to direct it.

Table 3.2 All Numbers Can Be Represented as Binary Numbers

Number

Binary Equivalent

0

00000000

1

00000001

2

00000010

3

00000011

4

00000100

5

00000101

6

00000110

7

00000111

8

00001000

9

00001001

10

00001010

11

00001011

12

00001100

13

00001101

14

00001110

15

00001111

16

00010000

17

00010001

18

00010010

19

00010011

20

00010100


To see an example of what goes on at the bit level, follow this example to see what happens when you ask the computer to subtract 65 from 65. The result should be zero and, as you can see from the following steps, that is exactly what the result is at the binary level.

TIP

The first 255 binary numbers overlap the ASCII table values. That is, the binary representation for the letter A is 01000001, and the binary number for 65 is also 01000001. The computer knows by the context of how your programs use the memory location whether the value is the letter A or the number 65.

  1. Suppose you want the computer to calculate the following:

    65 – 65

  2. The binary representation for 65 is 01000001, and the 2's complement for 65 is 10111111 (which is –65 in computerese). Therefore, you are requesting that the computer perform this calculation:

    01000001 + 10111111

  3. Because a binary number cannot have the digit 2 (there are only 0s and 1s in binary), the computer carries 1 anytime a calculation results in a value of 2; 1 + 1 equals 10 in binary. Although this can be confusing, you can make an analogy with decimal arithmetic. People work in a base 10 numbering system. (Binary is known as base 2.) There is no single digit to represent ten; we have to reuse two digits already used to form ten: 1 and 0. In base 10, 9 + 1 is 10. Therefore, the result of 1 + 1 in binary is 10 or "0 and carry 1 to the next column."

    01000001

    +10111111

    100000000

  4. Because the answer should fit within the same number of bits as the two original numbers (at least for this example—your computer may use more bits to represent numbers), the ninth bit is discarded, leaving the zero result. This example shows that binary 65 plus binary negative 65 equals zero as it should.

TIP

The good thing about all this binary arithmetic is that you don't have to understand a bit of it (pun intended) to be an expert programmer. Nevertheless, the more you know about what is going on under the hood, the better you will understand how programming languages work and the faster you will master new ones by seeing similarities between them.

  • + Share This
  • 🔖 Save To Your Account