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

2. Encoding Integers Sign Bit 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

3. 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

4. Unsigned & Signed Numeric Values
Given n bits, all a matter of mapping (rule) X
B2U(X)
B2S(X)
B2O(X)
B2T(X)
000
001 1
010 2
011 3
100 4 -0 -3 -4
101 5 -1 -2
110 6
111 7

5. 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

6. 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
-Tmin ?

7. Prob. 2.19 X
T2B4(X) -8 -3 -2 -1 5

8. Decimal Numbers Digits: 0,1,…9 49 – 2
49 + (100 – 2) = = 147 = 47
2 – 49
2 + (100 – 49) = = 53 = -47
Pat ’s comp.
Pat ’s comp ..

9. 2.2. 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;

10. 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;

11. Casting Surprises Expression Evaluation 0 == 0U Constant1 Constant2
If mix unsigned and signed in single expression, signed values implicitly cast to unsigned
Including comparison operations <, >, ==, <=, >=
Examples for W = 8
Constant Constant2
0 == U
-1 <
-1 > U
127 >
127U <
(unsigned) -1 >
127 < U
127 > (int) 128U

12. Prob. 2.44 int x = foo(); /* arbitrary value */
int y = bar(); /* arbitrary value */
unsigned us = x; unsigned uy = y;
For any x and y, are the following always true ?
(x>0) || (x-1<0)
(x & 7) !=7 || (x<<29 < 0)
(x*x) >=0
x < 0 || -x <= 0
x > 0 || -x >= 0
x+y == uy+ux
x * ~y + uy * ux == -x

13. Why 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

14. 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

15. 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

16. 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

17. Shift Operations Left Shift: x << y Right Shift: x >> y
Shift bit-vector x left y positions
Throw away extra bits on left
Fill with 0’s on right
Right Shift: x >> y
Shift bit-vector x right y positions
Throw away extra bits on right
Logical shift
Fill with 0’s on left
Arithmetic shift
Replicate most significant bit on right
Useful with two’s complement integer representation
Argument x
<< 3
Log. >> 2
Arith. >>2
Argument x
<< 3
Log. >> 2
Arith. >> 2

18. Prob. 2.23 Given a 32-bit machine, int func1(unsigned word){
return (int) ((word <<24) >> 24); }
int func2(unsigned word){
return ((int) word <<24) >> 24;
w func1(w) func2(w) 0x 0x
0x000000C9
0xEDCBA987