The Binary Number System

• The base two number system is called binary.
• A single digit is sometimes called a bit short for Binary DigiT.
• A bit is either a 0 or a 1.
• An example:
  • $1001_2 = 1 \times 2^3 + 0 \times 2^2 + 0 \times 2^1 + 1\times 2^0$
  • $= 1 \times 8 + 0 \times 4 + 0 \times 2 + 1\times 1$
  • $ = 8 + 1 = 9_{10}$, but we don't' write the $_{10}$
• It is reasonable you be able to convert numbers from binary to decimal.
• It is probably worth memorizing the first 10 powers of 2.

  $2^0$	1
  $2^1$	2
  $2^2$	4
  $2^3$	8
  $2^4$	16
  $2^5$	32
  $2^6$	64
  $2^7$	128
  $2^8$	256
  $2^9$	512
  $2^{10}$	1024

• I convert from base 2 to base 10 just by writing out the polynomial
  • $10110010_2$
    • Count the digits, 8
    • $ 1 \times 2^7 + 1 \times 2^5 + 1 \times 2^4 + 1 \times 2^1$
    • $128 + 32 + 16 + 2$
    • $178$
  • Try this with $101010101_2$
    • $2^8 + 2^6 + 2^4 + 2^2+ 2^0$
    • $256 + 64 + 16 + 4 + 1$
    • 341
  • There is another way

    • start with 0.
      For each digit left to right
         multiply the value by 2.
         If the digit is a 1, add in 1.
                  

    • Try this with $10110010_2$

      0 * 2 = 0 + 1 = 1
      1 * 2 = 2 + 0 = 2
      2 * 2 = 4 + 1 = 5
      5 * 2 = 10 + 1 = 11
      11 * 2 = 22 + 0 = 22
      22 * 2 = 44 + 0 = 44
      44 * 2 = 88 + 1 = 89
      89 * 2 = 178 + 0 = 178
      

    • Try this with $101010101_2$

      0 * 2 = 0 + 1 = 1
      1 * 2 = 2 + 0  = 2;
      2 * 2 = 4 + 1= 5
      5 * 2 = 10 + 0 =  10
      10 * 2 = 20 + 1 = 21
      21 * 2 = 42 + 0 = 42 
      42 * 2 = 84 + 1 = 85 
      85 * 2 = 170 + 0 = 170 
      170 * 2 = 340 + 1 = 341.
      

• An algorithm is a set of instructions that solve a problem in a finite amount of time.
  • We can turn an algorithm into a program.
  • For the above algorithm, an assembly/machine language program for wombat might be

    • 'use memory location 0 for the accumulated total.
      ' use memory location 1 for the digit.
      ' store a 2 in memory location 2 for multiply
      0           addi 2                                     C2
      1           store 2                                    22
      '  clear out the accumulator    
      2           addi -2                                    C-2
      '
      3  top:     input                                      30
                ' if the input is negative stop
      4           jumpn done                                 A11
                  ' save the input
      5           store 1                                    21
                  ' load the old total
      6           load 0                                     10
                  ' multiply the old total by 2
      7           mult 2                                     72
                  ' add the new digit
      8           add 1                                      51
                  ' save the result
      9           store 0                                    20
                  ' get the next value.
      10         jump top                                    B3
      11 done:   load 0                                      10
                 write                                       40
                 stop                                        00
           
      C2 22 C-2 30 A11 21 10 72 51 20 B3 10 40 00
      

    • While this is a little harder for people, it is much easier to program.
    • By the way, this is known as Horner's Method..
      • This algorithm is thought to be hundreds of years old.