 ## Appendix B - Binary and Hexadecimal Numbers

People think in decimal numbers, using the ten digits 0, 1, 2, 3, 4, 5, 6, 7, 8, and 9. It turns out that computers are easier to make if they use binary numbers, which have only two digits: 0 and 1.

In decimal, you count 1, 2, ... 8, 9, 10, 11, 12, ... and so on. As soon as you have used the last available decimal digit in the units digit position, you go back to zero in that digit and increase the next digit to its left by one. Binary works the same way, except that we run out of digits much sooner: In binary, you count 1, 10, 11, 100, 101, 110, 111, 1000, and so on.

Any number we happen to think of can be written in binary. All that is necessary is to count in binary at the same time as you count in ordinary decimal, and when you reach the number you were thinking of in decimal, the binary number you reached at the same time is the same number in binary. This is a little slow (something like counting on your fingers). It works, but we would like to do it faster, so let's look for another analogy with decimal numbers.

When you talk about ninety-nine dollars, you do not mean that you are counting the dollars from one to ninety-nine. Rather, you think of writing a "9" which means "nine ten-dollar bills" and another "9" next to it which means "nine one-dollar bills". And for numbers over a hundred, you write a single digit which counts the hundreds. There is a peculiar similarity to the way we write one, ten, a hundred, etc: (1, 10, 100...). Notice that it is a "1" followed by some number of zeros. We can do the same in binary: 1, 10, 100... Only now, instead of being powers of ten, they represent powers of two. In decimal you multiply ten times itself four times to get ten thousand. In binary you multiply two times itself four times to get sixteen, but it is written the same way: 10000.

So we can think of a binary number as some number of ones, plus some number of twos, plus some number of fours, plus some number of eights, and so on. This is just like decimal, where a number is some number of ones plus some number of tens plus some number of hundreds, etc. In decimal you can have any number of each from zero to nine (because those are the digits you have to write it), but in binary you can have only zero or one of each.

Let us look at that ninety-nine again. We could say that it is the same as one 64 plus one 32 plus no 16 plus no 8 plus no 4 plus one 2 plus one 1. We can write this as:

```        decimal    binary
1 x 64 =     64 = 1000000
1 x 32 =     32 =  100000
0 x l6 =      0 =       0
0 x  8 =      0 =       0
0 x  4 =      0 =       0
1 x  2 =      2 =      10
1 x  1 =      1 =       1
99 = 1100011
```

Notice how many more digits it takes to write "1100011" than "99"! We are all much too lazy to do all that writing, so we bunch the binary digits into groups of four, and give them special names, which curiously happen to match the decimal numbers to some degree. Of course there are sixteen combinations of four binary digits, so we run out of decimal digits to name them with and so use the letters A, B, C, D, E, and F for the last six. We call this the hexadecimal number system, because there are sixteen possible digits (instead of ten or two). Everything else works the same way. Of course each digit represents some number of a power of sixteen (such as one, sixteen, two-hundred-fifty-six, etc.).

The computer uses binary inside. We use decimal outside. So we often use hexadecimal to communicate with the computer as a "bridge" between the two systems.

As far as the computer is concerned, hexadecimal is only a way of writing binary. Hexadecimal is not "only a way of writing decimal." You have to do some arithmetic to convert it. For small numbers, use the following table (which you'll soon memorize):

```     Decimal    Hex    Binary
0       0         0
1       1         1
2       2        10
3       3        11
4       4       100
5       5       101
6       6       110
7       7       111
8       8      1000
9       9      1001
10       A      1010
11       B      1011
12       C      1100
13       D      1101
14       E      1110
15       F      1111
```

To convert hexadecimal to decimal, you multiply each successive hex digit by its respective power of sixteen, then add the products. To convert from decimal to hexadecimal, you divide the decimal number by the largest possible power of sixteen; the quotient is the first hex digit; dividing the remainder by successively smaller powers of sixteen will give you the rest of the digits. These are the powers of sixteen you will need for this book:

```        Decimal         Hexadecimal
65536             10000
4096              1000
256               100
16                10
1                 1
```

### EXERCISES

1. Convert 1234 from decimal to hex.

```        1234 + 256 = 4 remainder 46
46 +  16 = 2 remainder 14
14 +   1 = E (14) remainder 0
^-- 42E is equivalent hex number
```
2. Convert 66666 from decimal to hex.

```        66666 + 65536 = 1 remainder 1130
1130 +  4096 = 0 remainder 1130
1130 +   256 = 4 remainder  106
106 +    16 = 6 remainder   10
10 +     1 = A remainder    0
^-- 1046A is equivalent hex number
```
3. Convert 1234 from hexadecimal to decimal.

```        1234 = 1x4096 + 2x256 + 3x16 + 4x1
=  4096  +  512  +  48  +  4
=  4660 in decimal
```

[ << Appendix A ] [ Index ]

* (A Short Course In Programming is Copyright 1980 by Tom Pittman, and is reproduced in TinyELF's help book with the author's permission. Visit Tom's website.)