Chapter 1, Basic Data Representation

• Overview
  • We are able to represent actual objects in an abstract manner
  • Example: rearrange furniture in your apartment
    • Just move it around to see where it fits
    • Make a model decide how things fit, them move objects
  • Which is better?
  • What quantities do you need to represent in this model?
  • What quantities do you NOT need to represent?
  • Every representation emphasizes a set of properties while ignoring others.
  • Numbers are an abstraction,
    • I have two children, what does this tell you?
  • It is often possible to develop different models or abstract representations for a single given physical object.
  • Again consider furniture, what quantities would you represent in a model when you were planning
    • A video game
    • Moving across country
    • Moving across town
    • Moving within your apartment
    • Selling everything
  • A symbolic representation is a representation constructed from a fixed alphabet.
    • An alphabet is a set of symbols
    • We will focus on an alphabet consisting of {0,1} (Why?)
    • Representing items based on this alphabet is called encoding.

• Most of us are very familiar with a abstract representation for may things: numbers.
  • How are number systems good and bad?
  • We will look at some number systems and see how they work and what they are good for.
  • As we do this, ask yourself, what is this system good for, where are it's weeknesses.
• Number Systems
  • What are numbers?
    • Not physical objects.
    • Abstractions.
  • Some Simple Number Systems
    • Stick Numbers
      • Each item is represented by a stick.
      • IE One stick for each student present.
      • A number is a set of sticks.
      • A stick is a unit symbol.
      • How do you do
        • Addition
        • Subtraction
        • Multiplication
        • Comparison
      • Where does this system have problems?
      • How does the position of a single stick matter?
    • Simple Grouping Systems
      • Grouping systems have different objects to represent quantities.
      • A number is represented by a set of these objects.
      • Coins - pennies - the unit symbol, nickels, dimes, ...
      • RISK (the game).
      • Larger quantities are possible
      • Does the position of an object within a number matter?
      • Multiple representations of a single number are possible.
        • Can we add a rule to change this?
    • Roman Numerals
      • This is a grouping system with a set of rules
      • Objects:

        Symbol	Meaning	Group
        I	Unit Symbol	Ones
        V	5 I's	Ones
        X	10 I's	Tens
        L	50 I's	Tens
        C	100 I's	Hundreds
        D	500 I's	Hundreds
        M	1,000 I's	Thousands

    • In addition, the position of a number is important.
      • Numbers are usually sorted by units
      • XXIII = 23
      • VII = 7
      • MMII = 2002
    • In addition, there is a rule
      • Subtraction Rule If a smaller unit is positioned to left of a larger unit, the number represented is the difference between those two units.
      • IX = 10-1 = 9
      • IV = 5-1 = 4
      • This rule only applies to a pair of symbols
      • IXC is not legal.
      • The First symbol must be a decimal symbol.
      • VX is not legal.
    • Large numbers are hard to represent
    • Arithmetic is very difficult.

• Positional Number Systems
  • Positional Number Systems
    • Roman numerals got us started using position to represent values.
    • A positional number system consists of an alphabet (0,1,2, ...)
    • Symbols in the alphabet are called digits.
    • It also has a base or a radix.
    • Numbers are represented as a series of digits
      • In base 10, 2109 = 2*10³+1*10²+0*10¹+9*10⁰
      • In general, let d_k be an element of the alphabet and let r be the radix
      • d_n-1...d₂d₁d₀ = d_n-1*r^n-1+ ... + d₂*r² +d₁*r¹+d₀*r⁰
    • In the computer we use binary
      • Alphabet = {0,1}, Binary DigiT (or bit)
      • Base = 2
      • Example: 1011 = 1x2³+0*2²+1*2¹+1*2⁰
    • We refer to the left most non zero digit as the most significant digit
    • We refer to the rightmost digit as the least significant digit
    • Since we use the same alphabet for many different base number systems, we:
      • Use the base as a subscript in base ten
      • 101₂ is a number in base 2
      • 101 ₃ is a number in base 3
      • If no subscript is given, we assume base 10
      • 101 is a number is base 10.
    • We frequently use two additional number systems.
      • Both of these provide shorthand for binary.
      • Octal or base 8
        • Group bits in groups of three from the LSB
        • Write down the octal digit
      • Hexadecimal, hex, or base 16
        • Additional Alphabet

          Symbol	Decimal Equiv
          A	10
          B	11
          C	12
          D	13
          E	14
          F	15

        • 1F₁₆ =16+15 = 31
        • 1F₁₆ = 0001 1111₂ = 31
        • 1F₁₆ = 011 111₂ = 37₈
  • Converting Between Bases
    • Converting to base 10.
      • This is simple. Write the expansion and evaluate it
      • 362₇ = 3*7²+6*7¹+2*7⁰ = 3*49+6*6+2 = 147 + 42 + 2 = 191
      • We can do this quickly using something called horner's algorithm:
        • c_n-1b^n-1+ c_n-2b^n-2+ ... c₂b²+ c₁b¹+ c₀b⁰= c₀+b*(c₁+b*(c₂+b*(... +b*(c_n-2+b*c_n-1))))
        • ax³+bx²+cx+d = d+x*(c+x*(b+x*a))
    • You can do this for other bases as well, but it is hard (I can't work in any base other than 2)
    • So I convert almost everything to base 10 then to the new base.
    • Converting from base 10:
      • This can be done by a series of divisions.
      • For Example convert 983 to base 2

        
        
        2|893
          ---
        2|446 R 1
          ---
        2|223 R 0
          ---
        2|111 R 1
          ---
         2|55 R 1
           --
         2|27 R 1
           --
         2|13 R 1
           --
          2|6 R 1
            -
          2|3 R 0
            -
            1 R 1
             

      • So 893 = 11 0111 1101 ₂

        8|893
          ---
        8|111 R 5
         ---- 
         8|13 R 7
           -- 
            1 R 5 
         

      • So 893 = 1575 ₈

        16|893
           --- 
         16|55 R 13  (D)
            --
             3 R 7
        

      • So 893 = 37D ₁₆
  • Fractional Values
    • This is not a tremendously important thing for us, but it does give us some ideas we will need later.
    • .132₄ = 1*4^-1+3*4^-2+2*4^-3 = .25 + .1875 + .03125 = .46875
    • Converting from base 10 is just a series of multiplies and subtractions.

      .46875*4 = 1.875  (Keep the 1)
      .875 * 4 = 3.5    (Keep the 3)
      .5 * 4 = 2.0      (Keep the 2)
      	

    • So .46875 = .132₄
    • The problem is some fractions that terminate in one base do not do so in another base.
    • Example: .6 in base 10 is what in base 8?

      .6*8 = 4.8    - .4
      .8*8 = 6.4    - .46
      .4*8 = 3.2    - .463
      .2*8 = 1.6    - .4631
      .6*8 = 4.8    - .46314
      	

    • Later we will discuss precision, and how we deal with this.

• Some notes on Binary
  • Binary Addition:
    • Number Facts:

      +	0	1
      0	0 C 0	1 C 0
      1	1 C 0	1 C 1

    • Example:

      1111 
       10110
      +11011
      ------
      110001
      

    • If a=b^c then log_ba = c
    • we tend to write log₂ as lg
    • We will use lg some this semester.
    • If we want to represent a number in binary, we will need lg(n)+1 binary digits to do so.
      • 8 = 2³ = 1000₂ (notice 4 digits)
      • 2² < 6 < 2³ = 110₂ (notice 3 digits)
      • What is the biggest number we can represent with 5 bits?
        • 2⁵ = 32, so it will take 6 digits to represent 32
        • so we can represent 2⁵-1 or 31.
      • you should probably memorize your powers of two up through 1024 (2¹⁰)

• Encoding Numbers
  • How do we encode integers?
  • Remember, we can only use the alphabet {0,1}
  • Sign Magnitude
    • Numbers are represented in binary
    • A 0 is added to the left if the number is positive
    • A 1 is added to the left it the number is negative
    • 74 = 0100 1010₂
    • -74 = 1100 1010 ₂
  • BCD
    • Binary Coded Decimal
    • 4 bits are used to encode a decimal digit
    • 1010 = +
    • 1011 = -
    • 132 = 1010 0001 0011 0010 _bcd
    • -132 = 1011 0001 0011 0010 _bcd
    • This is (sort of) easy to read, but not efficient within a machine.
  • 2's compliment
    • Addition and subtraction of Sign-Magnitude numbers requires special attention to the sign, it would be nice if we could eliminate this.
    • Consider 27 and 13

      27 = 0110112
      13 = 011012
      
      27+13, just do it.
      
         0+ 11011 
       + 0+ 01101
          ------ 
         0+101000 
      
      
      27-13
         13 is smaller than 27, so subtract and keep the sign.
      
         0 + 11011
       - 0 + 01101
         ---------
         0 + 01110
      
      13-27, 27 is larger, so subtract 13 from 27 and change the sign
      
         0 + 11011
       - 0 + 01101
         ---------
         1 + 01110
      
      Other cases are much the same.   
      (-13+27, -27+13, ...)
      

    • To avoid this, we can encode a number in 2's compliment notation.
    • To do this we need to specify a size.
    • IE 8 Bit 2's compliment, 16 bit 2's compliment.
    • To encode a number
      • Represent the magnitude of the number in binary using precision 1 bits.
      • If the number is negative, flip all of the bits and add 1.
      • Example 23 in 8 bits = 0001 0111₂
      • Example -23 in 8 bits

        23 = 0001 0111, flip the bits 1110 1000
                                    + 0000 0001
                                    -----------
                                      1110 1001
        	      

      • The if we are using n bits, we can represent the numbers -2^n-1 to 2^n-1-1
      • Consider n=3, -2² to 2²-1 or -4 to 3

        3 bit two's compliment	Decimal
        000	0
        001	1
        010	2
        011	3
        100	-4
        101	-3
        110	-2
        111	-1

    • The nice part about this system, is we just perform the arithmetic. We include the sign bit.
    • Example: 2+ (-1)

        010
      + 111
        ---
        001
      
      	 

    • The only thing we have to worry about is overflow.
    • If the carry into the sign is different from the carry out of the sign we have a problem, overflow.
    • Example 2+3

      010
      011
      ---
      101  (carry into sign 1, carry out 0).
      

      We will need to do this on the board to see the carry.
  • But this is ok, because 2+3 = 5 which is outside our range, and we have a mechanism to detect it.
  • To decode a negative number, flip the bits and add one again.

• Character Encoding
  • ASCII
    • You should be somewhat familiar with the ascii chart
    • American Standard Code for Information Interchange
    • Characters are represented by 7 bits.
    • man ascii on a unix box.
    • Note that this is a fixed length code, ie each character takes up the same number of bits.
    • This is also overkill since in 7 bits we can represent 2⁷ 128 characters.
    • Most systems today are byte addressable, so we usual get 8 bits for a character.
    • Some systems have defined an extended-ascii set which uses all 8 bits.
    • Example:

         100 0100 110 0001 100 1110 - what is this?
          4    4   6    1   6     E
            D        a         n
      
      

  • Huffman
    • Like BCD ascii is easy to decode, but takes more space.
    • Huffman code is built for a specific use of an alphabet
    • You need to analyze the frequency of use for each character.
    • Assume :

      Letter	Frequency	Huffman Code
      +	.48	1
      -	.29	01
      =	.18	001
      /	.05	000

    • Then 11011001 is + + - + =
    • Note take the first possible match we find.
    • For 2 bit fixed length we would need 10 bits to send the same message.
    • On average the message would take 1*.48+2*.29+3*.18+3*.05 = 1.75 characters.
    • In general this is the sum of all of the frequencies * bits in code.
    • To build a Huffman code, you need to frequency distribution.
    • Example:

      Letter	Frequency
      +	.48
      -	.29
      =	.18
      /	.05

    • We now construct a forest of single node trees.
    • 
    • Finding the two trees with the lowest frequency, merge them and produce a root node with the sum of the two frequencies. Label each of the branches with a 0 or a 1.
    • 
    • Continue this process.
    • 
    • 
    • The code constructed is:

      Letter	Code
      +	0
      -	10
      =	110
      /	111

    • A different tree selection in the algorithm would have given the original code (What selection or labeling algorithm?).
    • Note Huffman codes for a given alphabet and frequency distribution are not unique.

• Error Detection/Correction
  • Any time we store or transmit data, there is a chance for error.
  • Detecting such an error is Error Detection
  • Fixing such an error is Error Correction
  • Error detection is much more simple than error correction.
  • And less expensive too.
  • Hamming distance
    • The hamming distance measures how different two encodings are.
    • 1101 and 1101 have a hamming distance of 0
    • 1101 and 1001 have a hamming distance of 1
    • 1101 and 0001 have a hamming distance of 2
    • 1101 and 0011 have a hamming distance of 3
  • We can calculate the hamming distance for a code as the minimum hamming distance between any two encodings in the code.
  • The parity for a pattern is determined by
    • Counting the number of ones in the pattern
    • If this count is even, the parity of the pattern is even.
    • If this count is odd, the parity of the pattern is odd.
    • Example 1011 has odd parity
    • Example 1100 has even parity.
  • We often add a parity bit to an encoding to force the encoding to have either even or odd parity.
  • This is another use for the 8th bit in ascii.
  • With even or odd parity, a single bit flipped in transmission is detectable.
  • This is insufficient information to correct the error, just sufficient to detect it.