1. Integer Representations and Arithmetic
Signed vs unsigned representations
Conversions
Addition and subtraction
Multiplication
class03.ppt
F’02

2. Notations Assume we have a word X of size w. X: xw-1,xw-2,……..x0
B2U w: Binary to unsigned- unsigned representation
B2T w : Binary to two’s complement- 2’s comp. representation
UMAX w: unsigned maximum number
TMAX w: maximum in 2’s complement
UMIN, TMIN similar meanings

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

5. Values for Different Word Sizes
Observations
|TMin | = TMax + 1
Asymmetric range
UMax = 2 * TMax + 1

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

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

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

9. Relation Between Signed & Unsigned
uy = y + 2 * = y

10. Sign Extension Task: Rule: Given w-bit signed integer x
Convert it to w+k-bit integer with same value; useful when you transfer the contents of a small word to a larger one
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

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

12. Justification For Sign Extension
Prove Correctness by Induction on k: prove for extending one bit
Induction Step: extending by single bit maintains value
Proof:Show that B2Tw+1= B2Tw; write in open representation -
• • • X
X  +
w+1 w

13. Negating with Complement & Increment
Claim: Following Holds for 2’s Complement
~x + 1 == -x
Complement
Observation: ~x + x == 1111…112 == -1
Increment
~x + x + (-x + 1) == -1 + (-x + 1)
~x + 1 == -x 1 x ~x + -1

14. Comp. & Incr. Examples
x = 15213

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

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

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

18. Multiplication Computing Exact Product of w-bit numbers x, y Ranges
Either signed or unsigned
Ranges
Unsigned: 0 ≤ x * y ≤ (2w – 1) 2 = 22w – 2w+1 + 1
Up to 2w bits
Two’s complement min: x * y ≥ (–2w–1)*(2w–1–1) = –22w–2 + 2w–1
Up to 2w–1 bits
Two’s complement max: x * y ≤ (–2w–1) 2 = 22w–2
Up to 2w bits, but only for (TMinw)2
Maintaining Exact Results
Would need to keep expanding word size with each product computed
Done in software by “arbitrary precision” arithmetic packages

19. Unsigned Multiplication in C
• • •
Operands: w bits * v
• • •
True Product: 2*w bits
u · v
• • •
• • •
UMultw(u , v)
• • •
Discard w bits: w bits
Standard Multiplication Function
Ignores high order w bits
Implements Modular Arithmetic
UMultw(u , v) = u · v mod 2w

20. Unsigned vs. Signed Multiplication
Unsigned Multiplication
unsigned ux = (unsigned) x;
unsigned uy = (unsigned) y;
unsigned up = ux * uy
Truncates product to w-bit number up = UMultw(ux, uy)
Modular arithmetic: up = ux  uy mod 2w
Two’s Complement Multiplication
int x, y;
int p = x * y;
Compute exact product of two w-bit numbers x, y
Truncate result to w-bit number p = TMultw(x, y)

21. Multiplication Example
Consider two 5 bit numbers X and Y in 2’s c. representation
X= -3(10) , Y=3(10) X*Y= -9, which is represented in 5 bits as 10111
X= Y= in 10 digits: XxY= ,
Rightmost 5 digits give the correct unswer.
That is: as long as there is no flowing to more than w
its, direct multiplication gives the correct result.
For flowing results to 2w bits, other algorithms such as Booth’s are used.

22. Unsigned vs. Signed Multiplication
Unsigned Multiplication
unsigned ux = (unsigned) x;
unsigned uy = (unsigned) y;
unsigned up = ux * uy
Two’s Complement Multiplication
int x, y;
int p = x * y;
Relation
Signed multiplication gives same bit-level result as unsigned
up == (unsigned) p

23. Power-of-2 Multiply with Shift
Operation
u << k gives u * 2k
Both signed and unsigned: always fill in with zeros from the right side
Examples
u << 3 == u * 8
u << 5 - u << 3 == u * 24
Most machines shift and add much faster than multiply
Compiler generates this code automatically k u
• • •
Operands: w bits * 2k
••• 1
•••
True Product: w+k bits
u · 2k
• • •
•••
UMultw(u , 2k)
•••
•••
Discard k bits: w bits
TMultw(u , 2k)

24. Unsigned Power-of-2 Divide with Shift-(signed-unsigned different)
Quotient of Unsigned by Power of 2
u >> k gives  u / 2k  (rounds toward zero)
Uses logical shift: Fill in with zeros from the left k u
Binary Point
•••
•••
Operands: / 2k
••• 1
•••
Division:
u / 2k .
•••
•••
•••
Result:
 u / 2k 
•••
•••

25. Signed Power-of-2 Divide with Shift
Quotient of Signed by Power of 2
x >> k gives  x / 2k 
Uses arithmetic shift: fill in with the sign bit from the left
Rounds wrong direction when u < 0(not towards zero) 1
••• x 2k /
x / 2k
Division:
Operands: k
RoundDown(x / 2k)
Result: .
Binary Point

26. Correct Power-of-2 Divide
Quotient of Negative Number by Power of 2
Want  x / 2k  (Round Toward zero):
compute  (x+2k-1)/ 2k  (add 2k-1 and shift right by k digits): use the equality  x/y  =  x+y-1/y 
In C: (x + (1<<k)-1) >> k
Biases dividend toward 0
Example:
want to divide -5(1011) to 2 (k=1).
We would obtain -2 in C. But
No Biasing: 011 shifted one bit to the right results with 1101=-3
Biasing:1. Add 1: = 1100
2. shift right one bit: 1110= -2