1. Comp 21000 Integers Spring 2015 Topics Numeric Encodings
Unsigned & Two’s complement
Programming Implications
C promotion rules
Basic operations
Addition, negation, multiplication
Consequences of overflow
Using shifts to perform power-of-2 multiply/divide

2. C Puzzles Answers on the last slide
Assume machine with 32 bit word size, two’s complement integers
For each of the following C expressions, either:
Argue that is true for all argument values
Give example where not true
x < 0  ((x*2) < 0)
ux >= 0
x & 7 == 7  (x<<30) < 0
ux > -1
x > y  -x < -y
x * x >= 0
x > 0 && y > 0  x + y > 0
x >= 0  -x <= 0
x <= 0  -x >= 0
Initialization
int x = foo();
int y = bar();
unsigned ux = x;
unsigned uy = y;

3. Encoding Integers Unsigned Two’s Complement Sign Bit
short int x = ;
short int y = ;
Sign
Bit
C short 2 bytes long
Sign Bit
For 2’s complement, most significant bit indicates sign
0 for nonnegative
1 for negative

4. Negative numbers Problem: how do we represent negative numbers?
Sign-magnitude.
Wastes space (range decreases)
Not used anymore (was used on a few IBM mainframes in the dark ages)
2’s complement
Space efficient
Arithmetic works well

5. The structure of a signed integer (if we’re using sign-magnitude)
This is no longer used!

6. Instead of using sign magnitude…
We’ll break the number line in the middle

7. …and shift the right part of the number line to the left side to get…
two’s complement
…and shift the right part of the number line to the left side to get…
Note that negative numbers start with a 1, but starting with a 1 is not what makes the number negative.
Result is called 2’s complement.
There is an easy arithmetic way to convert numbers to their negative equivalent with 2’s complement.

8. 2’s complement
Rule:
Positive numbers: use the normal binary representation (first bit must be 0 if the number is positive).
Negative numbers:
find positive binary representation of the number
Take the complement of the binary number.
Add 1 to the result.
+2 =
-2 = Complement: 101
Take result and add 1: 101
+ 1
110 = –2

9. This is the absolute value of 110
2’s complement
Rule:
To find the value represented by a binary number that starts with a 1 (i.e., a negative number)
Take the complement of the binary number.
Add 1 to the result.
determine the decimal value
To find the value reprsented by 110
Take the Complement:
add 1 to the complement]
find the decimal value = +2
This is the absolute value of 110

10. 2’s complement range
There will be more negative numbers than positive numbers since 0 takes a positive space:

11. The signed integers for a four-bit cell

12. 2’s complement range Range for any cell size:
Smallest number is 1000… 0
Largest number is 0111…..1
The magnitude of the smallest negative number is 1 greater than the magnitude of the largest positive number.
Example: 6-bit cell: -32 to 31

13. Converting 2’s complement
If the number is positive, just convert directly to decimal.
= 42
If the number is negative:
Take the 2’s complement, find decimal equivalent, negate
Or find the magnitude by summing the place values of the 0’s in the original number, then add 1.
take complement:
add 1: =
convert: = 22
Answer: -22

14. Numeric Ranges Unsigned Values UMin = 0 UMax = 2w – 1
000…0
UMax = 2w – 1
111…1
Two’s Complement Values
TMin = –2w–1
100…0
TMax = 2w–1 – 1
011…1
Other Values
Minus 1
111…1
Values for W = 16

15. Values for Different Word Sizes
C Programming
 #include <limits.h>
K&R App. B11
Declares constants, e.g.,
 ULONG_MAX
 LONG_MAX
 LONG_MIN
Values platform-specific
Observations
|TMin | = TMax + 1
Asymmetric range
UMax = 2 * TMax + 1

16. Unsigned & Signed Numeric ValuesX
B2T(X)
B2U(X)
0000
0001 1
0010 2
0011 3
0100 4
0101 5
0110 6
0111 7 –8 8 –7 9 –6 10 –5 11 –4 12 –3 13 –2 14 –1 15
1000
1001
1010
1011
1100
1101
1110
1111
Equivalence
Same encodings for nonnegative values
Uniqueness
Every bit pattern represents unique integer value
Each representable integer has unique bit encoding
 Can Invert Mappings
U2B(x) = B2U-1(x)
Bit pattern for unsigned integer
T2B(x) = B2T-1(x)
Bit pattern for two’s comp integer

17. Casting Signed to Unsigned
C Allows Conversions from Signed to Unsigned
Resulting Value
No change in bit representation
Nonnegative values unchanged
ux = 15213
Negative values change into (large) positive values
uy = 50323
short int x = ;
unsigned short int ux = (unsigned short) x;
short int y = ;
unsigned short int uy = (unsigned short) y;

18. Relation between Signed & Unsigned
T2U
T2B
B2U
Two’s Complement
Unsigned
Maintain Same Bit Pattern x ux X +
• • • - ux x
w–1
+2w–1 – –2w–1 = 2*2w–1 = 2w

19. Relation Between Signed & Unsigned
The bits that are stored:
uy = y + 2 * = y =

20. Signed vs. Unsigned in C Constants Casting
By default are considered to be signed integers
Unsigned if have “U” as suffix
0U, U
Casting
Explicit casting between signed & unsigned same as U2T and T2U
int tx, ty;
unsigned ux, uy;
tx = (int) ux;
uy = (unsigned) ty;
Implicit casting also occurs via assignments and procedure calls
tx = ux;
uy = ty;

21. How is this converted to int?
Casting Surprises
Expression Evaluation
If mix unsigned and signed in single expression, signed values implicitly cast to unsigned
Including comparison operations <, >, ==, <=, >=
Examples for number of bits W = 32
Constant1 Constant2 Relation Evaluation
0 0U
-1 0
-1 0U U
-1 -2
(unsigned) -1 -2 U
(int) U
(0x7FFFFFFF) (0x )
0 0U == unsigned
-1 0 < signed
-1 0U > unsigned
> signed
U < unsigned
> signed
(unsigned) > unsigned
U < unsigned
(int) U > signed
How is this converted to int?

22. Explanation of Casting Surprises
2’s Comp.  Unsigned
Ordering Inversion
Negative  Big Positive
TMax
TMin –1 –2
UMax
UMax – 1
TMax + 1
2’s Comp.
Range
Unsigned

23. Sign Extension Task: Rule: Given w-bit signed integer x
Convert it to w+k-bit integer with same value
Rule:
Make k copies of sign bit:
X  = xw–1 ,…, xw–1 , xw–1 , xw–2 ,…, x0
• • • X
X  w k
k copies of MSB

24. Sign Extension Example
short int x = ;
int ix = (int) x;
short int y = ;
int iy = (int) y;
Decimal
Hex
Binary x
15213
3B 6D ix
B 6D y
-15213
C4 93 iy
FF FF C4 93
Converting from smaller to larger integer data type
C automatically performs sign extension

25. Justification For Sign Extension
Prove Correctness by Induction on k
Induction Step: extending by single bit maintains value
Key observation: –2w–1 = –2w +2w–1
Look at weight of upper bits:
X –2w–1 xw–1
X  –2w xw–1 + 2w–1 xw–1 = –2w–1 xw–1 -
• • • X
X  +
w+1 w

26. Why Should I Use Unsigned?
Don’t Use Just Because Number Nonzero
C compilers on some machines generate less efficient code
unsigned i;
for (i = 1; i < cnt; i++)
a[i] += a[i-1];
Easy to make mistakes: think about truncation
for (i = cnt-2; i >= 0; i--)
a[i] += a[i+1];
Do Use When Performing Modular Arithmetic
Multiprecision arithmetic
Other esoteric stuff: flags, mainpulating registers, addresses
Do Use When Need Extra Bit’s Worth of Range
Working right up to limit of word size

27. Negating with Complement & Increment
Claim: Following Holds for 2’s Complement
~x + 1 == -x
Complement
Observation: ~x + x == 1111…112 == -1
Increment
~x + x = - 1
~x + x + (-x + 1) == -1 + (-x + 1)
~x + 1 == -x
Warning: Be cautious treating int’s as integers
OK here 1 x ~x + -1

28. Comp. & Incr. Examples
x = 15213

29. Binary addition 1

30. Carry bit Problem: cells have fixed number of bits
If addition requires more bits, must carry a bit out. Called a carry bit or a carry out.
Example: 6-bit cell (assume unsigned)
Carry bit
Carry bit

31. Binary subtraction 0 1 11 10 6 0 0 1 1 3 0 0 1 1 (6 – 3 = 3)
(6 – 3 = 3)
When the bottom bit is larger than the top bit, must borrow from the next left position.

32. Subtraction: Carry bit
When subtract, may have to borrow.
If most significant bit needs a borrow, must carry a bit in. Called a carry in.
Set the C bit to indicate that the result is not valid.
Example: 6-bit cell (assume unsigned)
–58 ?
Carry bit
Carry bit

33. Visualizing Integer Addition
4-bit integers u, v
Compute true sum Add4(u , v)
Values increase linearly with u and v
Forms planar surface
May need extra bit
Largest 4 bit number = 15
= 30
30 = (5 bits)
Add4(u , v) v u

34. Unsigned Addition Standard Addition Function
• • •
Operands: w bits + v
• • •
True Sum: w+1 bits
u + v
• • •
Discard Carry: w bits
UAddw(u , v)
• • •
Standard Addition Function
Ignores carry output
Implements Modular Arithmetic
s = UAddw(u , v) = u + v mod 2w

35. Unsigned Addition Explanation for results 1 1 1 1 15 1 1 1 1 0 30 30
= 16 –16

36. Visualizing Unsigned Addition
Wraps Around
If true sum ≥ 2w
At most once
Overflow
UAdd4(u , v)
True Sum 2w
2w+1
Overflow v
Modular Sum u

37. Adding 2’s complement 0 0 1 +1 0 1 1 +3 1 1 0 –2
Just add as normal. Always works (ignore the carry bit). –2 – –2 –4

38. Two’s Complement Additionu
• • •
Operands: w bits + v
• • •
True Sum: w+1 bits
u + v
• • •
Discard Carry: w bits
TAddw(u , v)
• • •
TAdd and UAdd have Identical Bit-Level Behavior
Signed vs. unsigned addition in C:
int s, t, u, v;
s = (int) ((unsigned) u + (unsigned) v);
t = u + v
Will give s == t

39. Status bits CPU keeps track of 4 bits: CVZN bits
These are saved in a special register
A register has one word of storage
They are set when an arithmetic operation is performed
a few other operations in assembly language will also set them
Carry: bit that is carried out of an addition
overflow (v): set if the arithmetic overflows (see later slide)
zero (z): set to 1 if the result of the arithmetic was zero, otherwise the z bit is set to 0
negative (n): set to 1 if the result of the arithmetic is negative, otherwise the n bit is set to 0
Flag: C V Z N 1

40. Status Bits Example 1: 1 0 1 0 + 1 0 1 1 0 1 0 1 c: 1 z: 0 v: 1 n: 0
c: 1
z: 0
v: 0
n: 1
Example 3:
c: 1
z: 1
v: 0
n: 0
Example 4:
c: 1
z: 0
v: 0
n: 1

41. Overflow bit What if the result is too big for the number of bits?
Have overflow.
Carry bit no longer indicates whether the sum is in range.
CPU contains a special bit called the overflow bit denoted by the letter V
If sum is out of range, V = 1
Otherwise V = 0

42. Overflow bit
CPU will always set the V bit and continue. Does not care if V = 1 or if V = 0.
Note that overflow cannot occur if:
Adding two numbers of different signs
Result must be smaller than either number
Subtracting two numbers of same sign
This is the same as adding two numbers of different signs: x – y = x + (–y)

43. Detecting 2’s Comp. Overflow
Task
Given s = TAddw(u , v)
Determine if s = Addw(u , v)
Example
int s, u, v;
s = u + v;
Claim
Overflow iff either:
u, v < 0, s  0 (NegOver)
u, v  0, s < 0 (PosOver)
ovf = (u<0 == v<0) && (u<0 != s<0);
2w –1
2w–1
PosOver
NegOver

44. Characterizing TAdd Functionality True sum requires w+1 bits
Drop off MSB
Treat remaining bits as 2’s comp. integer
–2w –1
–2w
2w –1
2w–1
True Sum
TAdd Result
1 000…0
1 100…0
0 000…0
0 100…0
0 111…1
100…0
000…0
011…1
PosOver u v
< 0
> 0
NegOver
PosOver
TAdd(u , v)
NegOver
(NegOver)
(PosOver)

45. Visualizing 2’s Comp. Addition
NegOver
Values
4-bit two’s comp.
Range from -8 to +7
Wraps Around
If sum  2w–1
Becomes negative
At most once
If sum < –2w–1
Becomes positive
TAdd4(u , v) v u
PosOver

46. How do we get to bits?
We write programs in an abstract language like C How do we get to the binary representation? Compilers & Assemblers! We write x = 5. The compiler changes it into mov 5, 0x005F The assembler changes it into: 80483c7: 8b 45 5F
Compiler figures out that this is an integer and changes it into 2’s Complement

47. Conversions: see slide 17 When to use unsigned: see slide 26
C Puzzle Answers
Assume machine with 32 bit word size, two’s comp. integers
TMin makes a good counterexample in many cases
x < 0  ((x*2) < 0)
ux >= 0
x & 7 == 7  (x<<30) < 0
ux > -1
x > y  -x < -y
x * x >= 0
x > 0 && y > 0  x + y > 0
x >= 0  -x <= 0
x <= 0  -x >= 0
x < 0  ((x*2) < 0) False: TMin
ux >= 0 True: 0 = UMin
x & 7 == 7  (x<<30) < 0 True: x1 = 1
ux > -1 False: 0
x > y  -x < -y False: -1, TMin
x * x >= 0 False:
x > 0 && y > 0  x + y > 0 False: TMax, TMax
x >= 0  -x <= 0 True: –TMax < 0
x <= 0  -x >= 0 False: TMin
Conversions: see slide 17
Casting: see slide 20, 21
When to use unsigned: see slide 26