Download Integers - UNL CSE

Giving credit where credit is due
JDEP 284H
Foundations of Computer Systems
„ Most
of slides for this lecture are based on
slides created by Drs. Bryant and
O’Hallaron, Carnegie Mellon University.
Integers
„I
have modified them and added new
slides.
Dr. Steve Goddard
[email protected]
http://cse.unl.edu/~goddard/Courses/JDEP284
2
Topics
C Puzzles
„
Taken from old exams
Assume machine with 32 bit word size, two’s complement
integers
„
For each of the following C expressions, either:
„
„ Numeric
Encodings
zUnsigned & Two’s complement
„ Programming
Implications
z Argue that is true for all argument values
z Give example where not true
zC promotion rules
„ Basic
Initialization
zAddition, negation, multiplication
„ Programming
Implications
zConsequences of overflow
zUsing shifts to perform power-of-2
B2U(X ) =
w−1
∑ xi ⋅2
int y = bar();
• x > y
unsigned ux = x;
• x * x >= 0
B2T(X ) = − xw −1 ⋅2
i=0
w−1
+
w−2
Decimal
15213
-15213
Hex
3B 6D
C4 93
Weight
1
2
4
8
16
32
64
128
256
512
1024
2048
4096
8192
16384
-32768
Sum
Sign
Bit
Binary
00111011 01101101
11000100 10010011
Sign Bit
„
• x > 0 && y > 0
⇒ x + y > 0
• x >= 0
⇒ -x <= 0
• x <= 0
⇒ -x >= 0
4
15213: 00111011 01101101
-15213: 11000100 10010011
i
i=0
C short 2 bytes long
x
y
x =
y =
∑ xi ⋅2
short int x = 15213;
short int y = -15213;
„
⇒ -x < -y
Encoding Example (Cont.)
Two’s Complement
i
⇒ (x<<30) < 0
• x & 7 == 7
• ux > -1
3
Encoding Integers
• ux >= 0
int x = foo();
unsigned uy = y;
multiply/divide
Unsigned
⇒ ((x*2) < 0)
• x < 0
operations
For 2’s complement, most significant bit indicates sign
z 0 for nonnegative
z 1 for negative
5
15213
1
1
0
0
1
4
1
8
0
0
1
32
1
64
0
0
1
256
1
512
0
0
1
2048
1
4096
1
8192
0
0
0
0
15213
-15213
1
1
1
2
0
0
0
0
1
16
0
0
0
0
1
128
0
0
0
0
1
1024
0
0
0
0
0
0
1
16384
1 -32768
-15213
6
Page 1
Numeric Ranges
Unsigned Values
„ UMin
= 0
Values for Different Word Sizes
Two’s Complement Values
„ TMin
=
–2w–1
000…0
„
100…0
=
UMax
2w – 1
„
111…1
=
TMax
8
255
127
-128
UMax
TMax
TMin
2w–1 – 1
W
32
4,294,967,295
2,147,483,647
-2,147,483,648
16
65,535
32,767
-32,768
64
18,446,744,073,709,551,615
9,223,372,036,854,775,807
-9,223,372,036,854,775,808
011…1
Other Values
„ Minus 1
Decimal
65535
32767
-32768
-1
0
UMax
TMax
TMin
-1
0
„
111…1
Values for W = 16
Hex
FF FF
7F FF
80 00
FF FF
00 00
C Programming
Observations
|TMin | =
TMax + 1
„
#include <limits.h>
„
Declares constants, e.g.,
z K&R App. B11
z Asymmetric range
„
Binary
11111111 11111111
01111111 11111111
10000000 00000000
11111111 11111111
00000000 00000000
UMax
=
2 * TMax + 1
z ULONG_MAX
z LONG_MAX
z LONG_MIN
„
Values platform-specific
7
8
Unsigned & Signed Numeric Values
B2U(X)
0
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
X
0000
0001
0010
0011
0100
0101
0110
0111
1000
1001
1010
1011
1100
1101
1110
1111
B2T(X)
0
1
2
3
4
5
6
7
–8
–7
–6
–5
–4
–3
–2
–1
Casting Signed to Unsigned
Equivalence
„
C Allows Conversions from Signed to Unsigned
Same encodings for
nonnegative values
short int
x = 15213;
unsigned short int ux = (unsigned short) x;
short int
y = -15213;
unsigned short int uy = (unsigned short) y;
Uniqueness
„
„
Every bit pattern represents
unique integer value
Each representable integer
has unique bit encoding
Resulting Value
⇒ Can Invert Mappings
„
z Bit pattern for unsigned
T2B(x) =
No change in bit representation
Nonnegative values unchanged
„
Negative values change into (large) positive values
z ux = 15213
integer
„
„
„
U2B(x) = B2U-1(x)
B2T-1(x)
z uy = 50323
z Bit pattern for two’s comp
integer
9
10
Relation Between Signed & Unsigned
Relation between Signed & Unsigned
Two’s Complement
Unsigned
T2U
T2B
x
Weight
1
2
4
8
16
32
64
128
256
512
1024
2048
4096
8192
16384
32768
Sum
B2U
ux
X
Maintain Same Bit Pattern
-
w–1
ux + + +
• • •
0
+ ++
x
• • •
+ ++
-++
+2w–1 – –2w–1 = 2*2w–1 = 2w
⎧x
ux = ⎨
w
⎩x + 2
x≥0
x<0
„
11
uy
=
-15213
1
1
1
2
0
0
0
0
1
16
0
0
0
0
1
128
0
0
0
0
1
1024
0
0
0
0
0
0
1
16384
1 -32768
-15213
y + 2 * 32768
=
50323
1
1
1
2
0
0
0
0
1
16
0
0
0
0
1
128
0
0
0
0
1
1024
0
0
0
0
0
0
1
16384
1
32768
50323
y + 65536
12
Page 2
Signed vs. Unsigned in C
Casting Surprises
Expression Evaluation
Constants
„
„
„ If
mix unsigned and signed in single expression, signed values
implicitly cast to unsigned
„ Including comparison operations <, >, ==, <=, >=
By default are considered to be signed integers
Unsigned if have “U” as suffix
„ Examples
0U, 4294967259U
Casting
„
Explicit casting between signed & unsigned same as U2T and
T2U
0
-1
-1
2147483647
2147483647U
-1
(unsigned) -1
2147483647
2147483647
int tx, ty;
unsigned ux, uy;
tx = (int) ux;
uy = (unsigned) ty;
„
for W = 32
Constant1
Implicit casting also occurs via assignments and procedure calls
tx = ux;
uy = ty;
13
Constant2
Relation Evaluation
0U
0
0U
-2147483648
-2147483648
-2
-2
2147483648U
(int) 2147483648U
==
<
>
>
<
>
>
<
>
Explanation of Casting Surprises
Sign Extension
2’s Comp. → Unsigned
Task:
„
„
Ordering Inversion
Negative → Big Positive
UMax
UMax – 1
„
TMax + 1
TMax
TMax
„
Rule:
Unsigned
Range
„
„
Make k copies of sign bit:
X ′ = xw–1 ,…, xw–1 , xw–1 , xw–2 ,…, x0
w
X
0
–1
–2
14
Given w-bit signed integer x
Convert it to w+k-bit integer with same value
k copies of MSB
2’s Comp.
Range
unsigned
signed
unsigned
signed
unsigned
signed
unsigned
unsigned
signed
• • •
0
• • •
X′
• • •
TMin
short int x = 15213;
int
ix = (int) x;
short int y = -15213;
int
iy = (int) y;
„
„
6D
6D
93
93
Binary
00111011
00000000 00000000 00111011
11000100
11111111 11111111 11000100
16
Prove Correctness by Induction on k
„
Induction Step: extending by single bit maintains value
w
X
Decimal
Hex
3B
15213
15213 00 00 3B
C4
-15213
-15213 FF FF C4
w
Justification For Sign Extension
Sign Extension Example
x
ix
y
iy
• • •
k
15
01101101
01101101
10010011
10010011
X′
-
• • •
-+
• • •
w+1
Converting from smaller to larger integer data type
C automatically performs sign extension
„
„
Key observation:
–2w–1 = –2w +2w–1
Look at weight of upper bits:
X
X′
17
–2w–1 xw–1
–2w xw–1 + 2w–1 xw–1
=
–2w–1 xw–1
18
Page 3
Negating with Complement &
Increment
Why Should I Use Unsigned?
Don’t Use Just Because Number Nonzero
„
Claim: Following Holds for 2’s Complement
C compilers on some machines generate less efficient code
~x + 1 == -x
unsigned i;
for (i = 1; i < cnt; i++)
a[i] += a[i-1];
„
Complement
„
Observation: ~x + x == 1111…112 == -1
Easy to make mistakes
for (i = cnt-2; i >= 0; i--)
a[i] += a[i+1];
x
100 111 01
+ ~x
011 000 10
-1
111 111 11
Do Use When Performing Modular Arithmetic
„
„
Multiprecision arithmetic
Other esoteric stuff
Increment
Do Use When Need Extra Bit’s Worth of Range
„
Working right up to limit of word size
„
~x + x + (-x + 1)
== -1 + (-x + 1)
„
~x + 1
-x
==
Warning: Be cautious treating int’s
int’s as integers
„
19
Comp. & Incr. Examples
OK here
20
Unsigned Addition
x = 15213
x
~x
~x+1
y
Decimal
15213
-15214
-15213
-15213
Hex
3B 6D
C4 92
C4 93
C4 93
Binary
00111011 01101101
11000100 10010010
11000100 10010011
11000100 10010011
Decimal
0
-1
0
Hex
00 00
FF FF
00 00
• • •
v
• • •
u+v
• • •
UAddw(u , v)
• • •
+
True Sum: w+1 bits
Discard Carry: w bits
0
0
~0
~0+1
u
Operands: w bits
Binary
00000000 00000000
11111111 11111111
00000000 00000000
Standard Addition Function
„
Ignores carry output
Implements Modular Arithmetic
What is the complement and increment of 0?
s =
UAddw(u , v)
= u + v mod 2w
⎧ u+ v
UAdd w (u,v) = ⎨
w
⎩u + v − 2
u + v < 2w
u + v ≥ 2w
21
22
Visualizing Integer Addition
Add4(u , v)
Integer Addition
„
„
„
„
4-bit integers u, v
Compute true sum
Add4(u , v)
Values increase
linearly with u and v
Forms planar
surface
Visualizing Unsigned Addition
Overflow
Wraps Around
„
Integer Addition
„
32
If true sum ≥ 2w
At most once
True Sum
2w+1
28
24
20
UAdd4(u , v)
16
14
Overflow
12
10
16
14
12
10
8
8
2w
12
6
0
4
0
2
u
4
6
10
12
12
10
4
v
0
2
8
14
6
8
4
0
8
2
Modular Sum
6
0
4
0
u
14
23
v
2
4
6
2
8
10
12
0
14
24
Page 4
Mathematical Properties
Two’s Complement Addition
Modular Addition Forms an Abelian Group
„
• • •
v
• • •
u+v
• • •
TAddw(u , v)
• • •
+
0 ≤ UAddw(u , v) ≤ 2w –1
„
Commutative
„
Associative
„
0 is additive identity
True Sum: w+1 bits
Discard Carry: w bits
UAddw(u , v) = UAddw(v , u)
UAddw(t, UAddw(u , v)) = UAddw(UAddw(t, u ), v)
TAdd and UAdd have Identical BitBit-Level Behavior
„
UAddw(u , 0) = u
„
u
Operands: w bits
Closed under addition
Every element has additive inverse
z Let
UCompw (u ) = 2w – u
UAddw(u , UCompw (u )) = 0
„
Signed vs. unsigned addition in C:
int s, t, u, v;
s = (int) ((unsigned) u + (unsigned) v);
t = u + v
Will give s == t
25
26
Characterizing TAdd
Functionality
„
„
„
True Sum
0 111…1
True sum requires
w+1 bits
Drop off MSB
Treat remaining
bits as 2’s comp.
integer
0 100…0
2w–1
PosOver
NegOver
Values
TAdd Result
2w –1
„
011…1
„
0 000…0
1 100…0
PosOver
TAdd(u , v)
1 000…0
>0
v
<0
Visualizing 2’s Comp. Addition
0
000…0
–2w –1
–2w
Wraps Around
„
100…0
NegOver
u
If sum < –2w–1
z Becomes positive
w −1
>0
6
z At most once
„
<0
8
If sum ≥ 2w–1
z Becomes negative
NegOver
⎧u + v + 2
u + v < TMin w (NegOver)
⎪
TAddw (u,v) = ⎨u + v
TMinw ≤ u + v ≤ TMax w
w
−1
⎪
TMax w < u + v (PosOver)
⎩u + v − 2
TAdd4(u , v)
4-bit two’s comp.
Range from -8 to +7
z At most once
4
2
0
6
-2
4
2
-4
0
-6
-2
-8
-4
-8
-6
-4
u
v
-6
-2
0
2
4
-8
6
PosOver
27
28
Detecting 2’s Comp. Overflow
Mathematical Properties of TAdd
Task
Isomorphic Algebra to UAdd
„
„
„
2w–1
Given s = TAddw(u , v)
Determine if s = Addw(u , v)
Example
int s, u, v;
s = u + v;
PosOver
„
Two’s Complement Under TAdd Forms a Group
0
„
„
Overflow iff either:
Closed, Commutative, Associative, 0 is additive identity
Every element has additive inverse
Let
TCompw (u ) = U2T(UCompw(T2U(u ))
TAddw(u , TCompw (u )) = 0
Claim
„
TAddw(u , v) = U2T(UAddw(T2U(u ), T2U(v)))
z Since both have identical bit patterns
2w –1
NegOver
u, v < 0, s ≥ 0 (NegOver)
u, v ≥ 0, s < 0 (PosOver)
⎧−u
TCompw (u) = ⎨
⎩TMinw
ovf = (u<0 == v<0) && (u<0 != s<0);
29
u ≠ TMinw
u = TMinw
30
Page 5
Multiplication
Unsigned Multiplication in C
Computing Exact Product of w-bit numbers x, y
„
Either signed or unsigned
Operands: w bits
*
Ranges
„
True Product: 2*w bits u · v
Unsigned: 0 ≤ x * y ≤ (2w – 1) 2 = 22w – 2w+1 + 1
z Up to 2w bits
Two’s complement min: x * y ≥ (–2w–1)*(2w–1–1) = –22w–2 + 2w–1
„
Two’s complement max: x * y ≤ (–2w–1) 2 = 22w–2
z Up to 2w–1 bits
„
• • •
• • •
UMultw(u , v)
Ignores high order w bits
Implements Modular Arithmetic
Maintaining Exact Results
„
• • •
Standard Multiplication Function
z Up to 2w bits, but only for (TMinw)2
„
• • •
v
• • •
Discard w bits: w bits
„
u
UMultw(u , v)
Would need to keep expanding word size with each product
computed
Done in software by “arbitrary precision” arithmetic
packages
=
u · v mod 2w
31
32
Unsigned vs. Signed Multiplication
Unsigned vs. Signed Multiplication
Unsigned Multiplication
Unsigned Multiplication
unsigned ux = (unsigned) x;
unsigned uy = (unsigned) y;
unsigned up = ux * uy
„
„
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;
Two’s Complement Multiplication
int x, y;
int p = x * y;
„
„
Relation
„
Compute exact product of two w-bit numbers x, y
Truncate result to w-bit number p = TMultw(x, y)
„
Signed multiplication gives same bit-level result as unsigned
up == (unsigned) p
33
34
Power-of-2 Multiply with Shift
Unsigned Power-of-2 Divide with
Shift
Operation
Quotient of Unsigned by Power of 2
„
u << k gives u * 2k
„
u >> k gives ⎣ u / 2k ⎦
„
Both signed and unsigned
„
Uses logical shift
Operands: w bits
*
True Product: w+k bits
u · 2k
Discard k bits: w bits
Examples
„
u
k
• • •
2k
0 ••• 0 1 0 ••• 0 0
• • •
UMultw(u , 2k)
•••
k
/
0 ••• 0 0
Division:
0 ••• 0 0
Result:
TMultw(u , 2k)
„
u << 3
==
u << 5 - u << 3
„
Most machines shift and add much faster than multiply
u
Operands:
x
x >> 1
x >> 4
x >> 8
u * 8
==
u * 24
2k
•••
u / 2k
0 •••
•••
⎣ u / 2k ⎦
0 •••
•••
Division
15213
7606.5
950.8125
59.4257813
Binary Point
•••
0 ••• 0 1 0 ••• 0 0
Computed
15213
7606
950
59
Hex
3B 6D
1D B6
03 B6
00 3B
.
•••
Binary
00111011 01101101
00011101 10110110
00000011 10110110
00000000 00111011
z Compiler generates this code automatically
35
36
Page 6
Signed Power-of-2 Divide with Shift
Correct Power-of-2 Divide
Quotient of Signed by Power of 2
Quotient of Negative Number by Power of 2
„
x >> k gives ⎣ x / 2k ⎦
„
„
Uses arithmetic shift
Rounds wrong direction when u < 0
„
„
z In C: (x + (1<<k)-1) >> k
k
x
Operands:
2k
/
Division:
Result:
y
y >> 1
y >> 4
y >> 8
•••
z Biases dividend toward 0
Binary Point
•••
Case 1: No rounding
0 ••• 0 1 0 ••• 0 0
x / 2k
0 •••
•••
0 •••
•••
RoundDown(x /
2k)
Division
-15213
-7606.5
-950.8125
-59.4257813
Computed
-15213
-7607
-951
-60
Want ⎡ x / 2k ⎤ (Round Toward 0)
Compute as ⎣ (x+2k-1)/ 2k ⎦
Hex
C4 93
E2 49
FC 49
FF C4
.
Dividend:
•••
k
u
1
+2k +–1
Divisor:
/
0 ••• 0 0
0 ••• 0 0 1 ••• 1 1
1
Binary
11000100 10010011
11100010 01001001
11111100 01001001
11111111 11000100
•••
2k
•••
Binary Point
1 ••• 1 1
0 ••• 0 1 0 ••• 0 0
⎡ u / 2k ⎤
0 ••• 1 1 1
1
. 1 ••• 1 1
•••
Biasing has no effect
37
38
Properties of Unsigned Arithmetic
Correct Power-of-2 Divide (Cont.)
Case 2: Rounding
Unsigned Multiplication with Addition Forms
Commutative Ring
k
Dividend:
x
+2k +–1
1
•••
•••
0 ••• 0 0 1 ••• 1 1
„
1
„
Addition is commutative group
Closed under multiplication
„
Multiplication Commutative
„
Multiplication is Associative
„
1 is multiplicative identity
„
Multiplication distributes over addtion
•••
•••
0 ≤ UMultw(u , v) ≤ 2w –1
Binary Point
Incremented by 1
Divisor:
2k
/
⎡x/
2k
⎤
UMultw(u , v) = UMultw(v , u)
0 ••• 0 1 0 ••• 0 0
0 ••• 1 1 1
1
Biasing adds 1 to final result
•••
.
•••
UMultw(t, UMultw(u , v)) = UMultw(UMultw(t, u ), v)
Incremented by 1
UMultw(u , 1) = u
UMultw(t, UAddw(u , v)) = UAddw(UMultw(t, u ), UMultw(t, v))
39
40
Properties of Two’s Comp. Arithmetic
C Puzzle Answers
Isomorphic Algebras
„
„
Unsigned multiplication and addition
„
Two’s complement multiplication and addition
„
Assume machine with 32 bit word size, two’s comp. integers
TMin makes a good counterexample in many cases
z Truncating to w bits
z Truncating to w bits
Both Form Rings
„
Isomorphic to ring of integers mod 2w
Comparison to Integer Arithmetic
„
„
Both are rings
Integers obey ordering properties, e.g.,
u>0
u > 0, v > 0
„
⇒
⇒
u+v>v
u·v>0
⇒
False:
TMin
True:
0 = UMin
True:
x1 = 1
False:
0
False:
-1, TMin
False:
30426
x + y > 0
False:
TMax, TMax
⇒
-x <= 0
True:
–TMax < 0
⇒
-x >= 0
False:
TMin
‰
x < 0
‰
ux >= 0
‰
x & 7 == 7
‰
ux > -1
‰
x > y
‰
x * x >= 0
‰
x > 0 && y > 0
⇒
‰
x >= 0
‰
x <= 0
⇒
⇒
((x*2) < 0)
(x<<30) < 0
-x < -y
These properties are not obeyed by two’s comp. arithmetic
TMax + 1
==
15213 * 30426
TMin
== -10030 (16-bit words)
41
42
Page 7