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.

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.

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

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 = 011011₂
13 = 01101₂

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.

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

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.A
- 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:
- 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.

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

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

Letter	Code
+	0
-	10
=	110
/	111

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.