Representing Signed Integers

• We will look at a number of representations for integers in a little more deatil that before.
  • We will consider how to perform
    • Negation
    • Addition
    • Subtraction
    • Absolute Value
    • ...
  • We should also consider sign extension (for shifts, and loads)
  • Size Reduction (after a multiply or division)
  • We will note the representation of a number x as rep(x)
• Sign Magnitude
  • As before, we use one bit as a sign bit
  • If the first bit (MSB) is a 1, we have a negative number
  • Example: consider a 6 bit sign-magnitude representation
    • rep(-9) = 101001
    • rep(9) = 001001
  • How do we do negation, absolute value?
  • The only problem we have is with 0, -0 = 0 but we dont normally have a -0.
  • Let ~rep(x) be the sign magnitude negation operator. (IE flip the first bit)
  • ~rep(x) = rep (-x) should be true
  • We could attempt to prove this by arguing cases
    • let b be the binary representation of abs(x)
    • If x is 0 : special case, it works
    • If x < 0 : rep(x) = 1b, ~rep(x) = 0b, 0b = -x
    • If x > 0 : as above
  • This would provie that our operation is correct.
  • Subtraction and Addition
    • The same operation , consider addition
    • If the signs are the same, just add
    • If the signs are different, subtract
    • x+y (both are sign magnitude numbers)
      • if x > 0, y>0: x+y
      • if x < 0, y < 0: ~rep(|x|+|y|)
      • otherwise: rep(x) -_sm ~rep(y)
    • Note, in the last case, we push the problem off to subtraction
    • For subtraction, we can do the same thing.
    • x-y
      • x > y > 0: rep(x) - rep(y)
      • y > x > 0 : ~(rep(y)-rep(x))
      • 0 > y > x : ~(rep(x) - rep(y))
      • 0 > x > y : |rep(y)| - |rep(x)|
      • Otherwise: rep(x) +_sm ~rep(y)
    • This is quite a pain, we need to worry about all of these cases
      • This means more complex control
      • It also means we need to do comparisons before we do the math
      • Doesn't seem like a good idea to me.
• Excess
  • Start with a number
  • Add a bias from this
  • rep(x) = bin(x+b) where b is the bias
  • This is essentually scaling the range.
  • A 4 bit excess 8 representation

  • -8+8 = 0  0000
    8+7 = 15  1111
    
    0000 0001 0010 0011 0100 0101 0110 0111 1000 1001 1010 1011 1100 1101 1110 1111
     -8   -7  -6    -5   -4   -3   -2   -1   0    1    2    3    4    5    6    7
           

  • The range is variable, but one number per rep.
  • We could also do 4 bit excess 7 (-7 to 8)
  • In this case, the first bit is an inverse sign bit.
  • But this might not work for 0.
  • A number is really x+b, so to negate we want it to be -x+b

    rep(x) - b = x
     x+b-b = x
     -(x+b-b)= -x
     b-(x+b-b) = rep(-x) = ~rep(x)
           

  • However we need to be careful that we don't overflow work area.
  • ~rep(x) =
    • x>= 0 , b-(rep(x)-b)
    • x< 0 , b+(b-rep(x))
  • Absolute value is more of a problem.
  • In addition and subtraction we have a problem too

    •   rep(x) + rep(y) = x+b + y+b
                        = (x+y) + b + b
      		  = rep(x+y) + b
                     

    • so x+y = rep(x) + rep(y) - b;
    • Again, care must be taken to insure the minimal chance of overflow
  • Sign extension is bad
    • Probably implies a bias change.
    • Not hard, but computationaly not simple.
• 2's compliment
  • We know the process
  • Negation?
  • Addition/subtraction?
  • How about extension?
  • Remember we want the folowing condition codes set
    • z - the result is zero
    • n - the result is not zero
    • V - overflow
  • Take a look at what we can do with 2s compliment and an n bit adder
    • For addition, send a 0 in
    • For subtraction send a 1 in
  • 
• 1's compliment
  • I'm going to skip this one.