doc/bin_dec_hex.txt

   1 BIN_DEC_HEX(1)                      rrdtool                     BIN_DEC_HEX(1)
   2
   3
   4
   5 N\bNA\bAM\bME\bE
   6        bin_dec_hex - How to use binary, decimal, and hexadecimal notation.
   7
   8 D\bDE\bES\bSC\bCR\bRI\bIP\bPT\bTI\bIO\bON\bN
   9        Most people use the decimal numbering system. This system uses ten sym-
  10        bols to represent numbers. When those ten symbols are used up, they
  11        start all over again and increment the position to the left. The digit
  12        0 is only shown if it is the only symbol in the sequence, or if it is
  13        not the first one.
  14
  15        If this sounds cryptic to you, this is what I've just said in numbers:
  16
  17             0
  18             1
  19             2
  20             3
  21             4
  22             5
  23             6
  24             7
  25             8
  26             9
  27            10
  28            11
  29            12
  30            13
  31
  32        and so on.
  33
  34        Each time the digit nine is incremented, it is reset to 0 and the posi-
  35        tion before (to the left) is incremented (from 0 to 1). Then number 9
  36        can be seen as "00009" and when we should increment 9, we reset it to
  37        zero and increment the digit just before the 9 so the number becomes
  38        "00010". Leading zeros we don't write except if it is the only digit
  39        (number 0). And of course, we write zeros if they occur anywhere inside
  40        or at the end of a number:
  41
  42         "00010" -> " 0010" -> " 010" -> "  10", but not "  1 ".
  43
  44        This was pretty basic, you already knew this. Why did I tell it?  Well,
  45        computers usually do not represent numbers with 10 different digits.
  46        They only use two different symbols, namely "0" and "1". Apply the same
  47        rules to this set of digits and you get the binary numbering system:
  48
  49             0
  50             1
  51            10
  52            11
  53           100
  54           101
  55           110
  56           111
  57          1000
  58          1001
  59          1010
  60          1011
  61          1100
  62          1101
  63
  64        and so on.
  65
  66        If you count the number of rows, you'll see that these are again 14
  67        different numbers. The numbers are the same and mean the same as in the
  68        first list, we just used a different representation. This means that
  69        you have to know the representation used, or as it is called the num-
  70        bering system or base.  Normally, if we do not explicitly specify the
  71        numbering system used, we implicitly use the decimal system. If we want
  72        to use any other numbering system, we'll have to make that clear. There
  73        are a few widely adopted methods to do so. One common form is to write
  74        1010(2) which means that you wrote down a number in its binary repre-
  75        sentation. It is the number ten. If you would write 1010 without speci-
  76        fying the base, the number is interpreted as one thousand and ten using
  77        base 10.
  78
  79        In books, another form is common. It uses subscripts (little charac-
  80        ters, more or less in between two rows). You can leave out the paren-
  81        theses in that case and write down the number in normal characters fol-
  82        lowed by a little two just behind it.
  83
  84        As the numbering system used is also called the base, we talk of the
  85        number 1100 base 2, the number 12 base 10.
  86
  87        Within the binary system, it is common to write leading zeros. The num-
  88        bers are written down in series of four, eight or sixteen depending on
  89        the context.
  90
  91        We can use the binary form when talking to computers (...program-
  92        ming...), but the numbers will have large representations. The number
  93        65'535 (often in the decimal system a ' is used to separate blocks of
  94        three digits for readability) would be written down as
  95        1111111111111111(2) which is 16 times the digit 1.  This is difficult
  96        and prone to errors. Therefore, we usually would use another base,
  97        called hexadecimal. It uses 16 different symbols. First the symbols
  98        from the decimal system are used, thereafter we continue with alpha-
  99        betic characters. We get 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, A, B, C, D, E
 100        and F. This system is chosen because the hexadecimal form can be con-
 101        verted into the binary system very easily (and back).
 102
 103        There is yet another system in use, called the octal system. This was
 104        more common in the old days, but is not used very often anymore. As you
 105        might find it in use sometimes, you should get used to it and we'll
 106        show it below. It's the same story as with the other representations,
 107        but with eight different symbols.
 108
 109         Binary      (2)
 110         Octal       (8)
 111         Decimal     (10)
 112         Hexadecimal (16)
 113
 114         (2)    (8) (10) (16)
 115         00000   0    0    0
 116         00001   1    1    1
 117         00010   2    2    2
 118         00011   3    3    3
 119         00100   4    4    4
 120         00101   5    5    5
 121         00110   6    6    6
 122         00111   7    7    7
 123         01000  10    8    8
 124         01001  11    9    9
 125         01010  12   10    A
 126         01011  13   11    B
 127         01100  14   12    C
 128         01101  15   13    D
 129         01110  16   14    E
 130         01111  17   15    F
 131         10000  20   16   10
 132         10001  21   17   11
 133         10010  22   18   12
 134         10011  23   19   13
 135         10100  24   20   14
 136         10101  25   21   15
 137
 138        Most computers used nowadays are using bytes of eight bits. This means
 139        that they store eight bits at a time. You can see why the octal system
 140        is not the most practical for that: You'd need three digits to repre-
 141        sent the eight bits and this means that you'd have to use one complete
 142        digit to represent only two bits (2+3+3=8). This is a waste. For hex-
 143        adecimal digits, you need only two digits which are used completely:
 144
 145         (2)      (8)  (10) (16)
 146         11111111 377  255   FF
 147
 148        You can see why binary and hexadecimal can be converted quickly: For
 149        each hexadecimal digit there are exactly four binary digits.  Take a
 150        binary number: take four digits from the right and make a hexadecimal
 151        digit from it (see the table above). Repeat this until there are no
 152        more digits. And the other way around: Take a hexadecimal number. For
 153        each digit, write down its binary equivalent.
 154
 155        Computers (or rather the parsers running on them) would have a hard
 156        time converting a number like 1234(16). Therefore hexadecimal numbers
 157        are specified with a prefix. This prefix depends on the language you're
 158        writing in. Some of the prefixes are "0x" for C, "$" for Pascal, "#"
 159        for HTML.  It is common to assume that if a number starts with a zero,
 160        it is octal. It does not matter what is used as long as you know what
 161        it is. I will use "0x" for hexadecimal, "%" for binary and "0" for
 162        octal.  The following numbers are all the same, just their representa-
 163        tion (base) is different: 021 0x11 17 %00010001
 164
 165        To do arithmetics and conversions you need to understand one more
 166        thing.  It is something you already know but perhaps you do not "see"
 167        it yet:
 168
 169        If you write down 1234, (no prefix, so it is decimal) you are talking
 170        about the number one thousand, two hundred and thirty four. In sort of
 171        a formula:
 172
 173         1 * 1000 = 1000
 174         2 *  100 =  200
 175         3 *   10 =   30
 176         4 *    1 =    4
 177
 178        This can also be written as:
 179
 180         1 * 10^3
 181         2 * 10^2
 182         3 * 10^1
 183         4 * 10^0
 184
 185        where ^ means "to the power of".
 186
 187        We are using the base 10, and the positions 0,1,2 and 3.  The right-
 188        most position should NOT be multiplied with 10. The second from the
 189        right should be multiplied one time with 10. The third from the right
 190        is multiplied with 10 two times. This continues for whatever positions
 191        are used.
 192
 193        It is the same in all other representations:
 194
 195        0x1234 will be
 196
 197         1 * 16^3
 198         2 * 16^2
 199         3 * 16^1
 200         4 * 16^0
 201
 202        01234 would be
 203
 204         1 * 8^3
 205         2 * 8^2
 206         3 * 8^1
 207         4 * 8^0
 208
 209        This example can not be done for binary as that system only uses two
 210        symbols. Another example:
 211
 212        %1010 would be
 213
 214         1 * 2^3
 215         0 * 2^2
 216         1 * 2^1
 217         0 * 2^0
 218
 219        It would have been easier to convert it to its hexadecimal form and
 220        just translate %1010 into 0xA. After a while you get used to it. You
 221        will not need to do any calculations anymore, but just know that 0xA
 222        means 10.
 223
 224        To convert a decimal number into a hexadecimal you could use the next
 225        method. It will take some time to be able to do the estimates, but it
 226        will be easier when you use the system more frequently. We'll look at
 227        yet another way afterwards.
 228
 229        First you need to know how many positions will be used in the other
 230        system. To do so, you need to know the maximum numbers you'll be using.
 231        Well, that's not as hard as it looks. In decimal, the maximum number
 232        that you can form with two digits is "99". The maximum for three:
 233        "999". The next number would need an extra position. Reverse this idea
 234        and you will see that the number can be found by taking 10^3 (10*10*10
 235        is 1000) minus 1 or 10^2 minus one.
 236
 237        This can be done for hexadecimal as well:
 238
 239         16^4 = 0x10000 = 65536
 240         16^3 =  0x1000 =  4096
 241         16^2 =   0x100 =   256
 242         16^1 =    0x10 =    16
 243
 244        If a number is smaller than 65'536 it will fit in four positions.  If
 245        the number is bigger than 4'095, you must use position 4.  How many
 246        times you can subtract 4'096 from the number without going below zero
 247        is the first digit you write down. This will always be a number from 1
 248        to 15 (0x1 to 0xF). Do the same for the other positions.
 249
 250        Let's try with 41'029. It is smaller than 16^4 but bigger than 16^3-1.
 251        This means that we have to use four positions.  We can subtract 16^3
 252        from 41'029 ten times without going below zero.  The left-most digit
 253        will therefore be "A", so we have 0xA????.  The number is reduced to
 254        41'029 - 10*4'096 = 41'029-40'960 = 69.  69 is smaller than 16^3 but
 255        not bigger than 16^2-1. The second digit is therefore "0" and we now
 256        have 0xA0??.  69 is smaller than 16^2 and bigger than 16^1-1. We can
 257        subtract 16^1 (which is just plain 16) four times and write down "4" to
 258        get 0xA04?.  Subtract 64 from 69 (69 - 4*16) and the last digit is 5
 259        --> 0xA045.
 260
 261        The other method builds up the number from the right. Let's try 41'029
 262        again.  Divide by 16 and do not use fractions (only whole numbers).
 263
 264         41'029 / 16 is 2'564 with a remainder of 5. Write down 5.
 265         2'564 / 16 is 160 with a remainder of 4. Write the 4 before the 5.
 266         160 / 16 is 10 with no remainder. Prepend 45 with 0.
 267         10 / 16 is below one. End here and prepend 0xA. End up with 0xA045.
 268
 269        Which method to use is up to you. Use whatever works for you.  I use
 270        them both without being able to tell what method I use in each case, it
 271        just depends on the number, I think. Fact is, some numbers will occur
 272        frequently while programming. If the number is close to one I am famil-
 273        iar with, then I will use the first method (like 32'770 which is into
 274        32'768 + 2 and I just know that it is 0x8000 + 0x2 = 0x8002).
 275
 276        For binary the same approach can be used. The base is 2 and not 16, and
 277        the number of positions will grow rapidly. Using the second method has
 278        the advantage that you can see very easily if you should write down a
 279        zero or a one: if you divide by two the remainder will be zero if it is
 280        an even number and one if it is an odd number:
 281
 282         41029 / 2 = 20514 remainder 1
 283         20514 / 2 = 10257 remainder 0
 284         10257 / 2 =  5128 remainder 1
 285          5128 / 2 =  2564 remainder 0
 286          2564 / 2 =  1282 remainder 0
 287          1282 / 2 =   641 remainder 0
 288           641 / 2 =   320 remainder 1
 289           320 / 2 =   160 remainder 0
 290           160 / 2 =    80 remainder 0
 291            80 / 2 =    40 remainder 0
 292            40 / 2 =    20 remainder 0
 293            20 / 2 =    10 remainder 0
 294            10 / 2 =     5 remainder 0
 295             5 / 2 =     2 remainder 1
 296             2 / 2 =     1 remainder 0
 297             1 / 2 below 0 remainder 1
 298
 299        Write down the results from right to left: %1010000001000101
 300
 301        Group by four:
 302
 303         %1010000001000101
 304         %101000000100 0101
 305         %10100000 0100 0101
 306         %1010 0000 0100 0101
 307
 308        Convert into hexadecimal: 0xA045
 309
 310        Group %1010000001000101 by three and convert into octal:
 311
 312         %1010000001000101
 313         %1010000001000 101
 314         %1010000001 000 101
 315         %1010000 001 000 101
 316         %1010 000 001 000 101
 317         %1 010 000 001 000 101
 318         %001 010 000 001 000 101
 319            1   2   0   1   0   5 --> 0120105
 320
 321         So: %1010000001000101 = 0120105 = 0xA045 = 41029
 322         Or: 1010000001000101(2) = 120105(8) = A045(16) = 41029(10)
 323         Or: 1010000001000101(2) = 120105(8) = A045(16) = 41029
 324
 325        At first while adding numbers, you'll convert them to their decimal
 326        form and then back into their original form after doing the addition.
 327        If you use the other numbering system often, you will see that you'll
 328        be able to do arithmetics directly in the base that is used.  In any
 329        representation it is the same, add the numbers on the right, write down
 330        the right-most digit from the result, remember the other digits and use
 331        them in the next round. Continue with the second digit from the right
 332        and so on:
 333
 334            %1010 + %0111 --> 10 + 7 --> 17 --> %00010001
 335
 336        will become
 337
 338            %1010
 339            %0111 +
 340             ||||
 341             |||+-- add 0 + 1, result is 1, nothing to remember
 342             ||+--- add 1 + 1, result is %10, write down 0 and remember 1
 343             |+---- add 0 + 1 + 1(remembered), result = 0, remember 1
 344             +----- add 1 + 0 + 1(remembered), result = 0, remember 1
 345                    nothing to add, 1 remembered, result = 1
 346         --------
 347           %10001 is the result, I like to write it as %00010001
 348
 349        For low values, try to do the calculations yourself, then check them
 350        with a calculator. The more you do the calculations yourself, the more
 351        you'll find that you didn't make mistakes. In the end, you'll do cal-
 352        culi in other bases as easily as you do them in decimal.
 353
 354        When the numbers get bigger, you'll have to realize that a computer is
 355        not called a computer just to have a nice name. There are many differ-
 356        ent calculators available, use them. For Unix you could use "bc" which
 357        is short for Binary Calculator. It calculates not only in decimal, but
 358        in all bases you'll ever want to use (among them Binary).
 359
 360        For people on Windows: Start the calculator (start->programs->acces-
 361        sories->calculator) and if necessary click view->scientific. You now
 362        have a scientific calculator and can compute in binary or hexadecimal.
 363
 364 A\bAU\bUT\bTH\bHO\bOR\bR
 365        I hope you enjoyed the examples and their descriptions. If you do, help
 366        other people by pointing them to this document when they are asking
 367        basic questions. They will not only get their answer, but at the same
 368        time learn a whole lot more.
 369
 370        Alex van den Bogaerdt  <alex@vandenbogaerdt.nl>
 371
 372
 373
 374 1.3.99909060808                   2009-02-21                    BIN_DEC_HEX(1)