Integers Today Numeric Encodings Programming Implications Basic operations

Integers Today Numeric Encodings • Programming Implications • Basic operations • Programming Implications • Next time • Fabián E. Bustamante, Spring 2007 Floats

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: – Argue that is true for all argument values – Give example where not true ((x*2) < 0) • x < 0 • ux >= 0 • x & 7 == 7 (x<<30) < 0 • ux > -1 • x > y unsigned ux = x; • x * x >= 0 unsigned uy = y; • x > 0 && y > 0 • x >= 0 -x <= 0 • x <= 0 -x >= 0 Initialization int x = foo(); int y = bar(); -x < -y EECS 213 Introduction to Cmputer Systems Northwestern University x + y > 0 2

Encoding integers Unsigned Two’s Complement short int x = 15213; short int y = -15213; – C short 2 bytes long Sign Bit Sign bit – For 2’s complement, most significant bit indicates sign • 0 for nonnegative • 1 for negative EECS 213 Introduction to Computer Systems Northwestern University 3

Encoding example x = 15213: 00111011 01101101 y = -15213: 11000100 10010011 EECS 213 Introduction to Computer Systems Northwestern University 4

Numeric ranges Unsigned Values – Umin = 0 • 000… 0 – UMax = 2 w-1 • 111… 1 Two’s Complement Values – Tmin = – 2 w– 1 • 100… 0 – TMax = 2 w– 1 • 011… 1 Other Values – Minus 1 Values for W = 16 • 111… 1 EECS 213 Introduction to Computer Systems Northwestern University 5

Values for other word sizes Observations – |TMin | = C Programming |TMax | + 1 • Asymmetric range – UMax = 2 * TMax + 1 – #include <limits. h> – Declares constants, e. g. , • • • ULONG_MAX LONG_MIN – Values platform-specific EECS 213 Introduction to Computer Systems Northwestern University 6

Unsigned & signed numeric values X 0000 0001 0010 0011 0100 0101 0110 0111 1000 1001 1010 1011 1100 1101 1110 1111 B 2 U(X) 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 B 2 T(X) 0 1 2 3 4 5 6 7 – 8 – 7 – 6 – 5 – 4 – 3 – 2 – 1 Equivalence – Same encodings for nonnegative values Uniqueness (bijections) – Every bit pattern represents unique integer value – Each representable integer has unique bit encoding Can invert mappings – U 2 B(x) = B 2 U-1(x) • Bit pattern for unsigned integer – T 2 B(x) = B 2 T-1(x) • Bit pattern for two’s comp integer EECS 213 Introduction to Computer Systems Northwestern University 7

Casting signed to unsigned C allows conversions from signed to unsigned short int x = 15213; unsigned short int ux = (unsigned short) x; short int y = -15213; unsigned short int uy = (unsigned short) y; Resulting value – No change in bit representation – Non-negative values unchanged • ux = 15213 – Negative values change into (large) positive values • uy = 50323 EECS 213 Introduction to Computer Systems Northwestern University 8

Relation between signed & unsigned Casting from signed to unsigned Two’s Complement Unsigned T 2 U T 2 B x B 2 U ux X Maintain same bit pattern Consider B 2 U and B 2 T equations and a bit pattern X; compute B 2 U(X) – B 2 T(X) weighted sum of for bits from 0 to w – 2 cancel each other If we let EECS 213 Introduction to Computer Systems Northwestern University 9

Relation between signed & unsigned ux = x + 216 = -15213 + 65536 EECS 213 Introduction to Computer Systems Northwestern University 10

Conversion - graphically 2’s Comp. Unsigned – Ordering inversion – Negative Big positive TMax 2’s Comp. Range UMax – 1 TMax + 1 Unsigned TMax 0111 Range 0000 0 – 1 – 2 TMin 1111 0 1000 EECS 213 Introduction to Computer Systems Northwestern University 11

Signed vs. unsigned in C Constants – By default are considered to be signed integers – Unsigned if have “U” as suffix 0 U, 4294967259 U Casting – Explicit casting bet/ signed & unsigned same as U 2 T and T 2 U int tx, ty; unsigned ux, uy; tx = (int) ux; uy = (unsigned) ty; – Implicit casting also occurs via assignments & procedure calls tx = ux; uy = ty; EECS 213 Introduction to Computer Systems Northwestern University 12

Casting surprises Expression evaluation – If mix unsigned and signed in single expression, signed values implicitly cast to unsigned – Including comparison operations <, >, ==, <=, >= – Examples for W = 32 Expression Type Eval unsigned 1 0 == 0 U signed 1 -1 < 0 unsigned 0 -1 < 0 U signed 1 2147483647 > -2147483648 2147483647 U > -2147483648 unsigned 0 signed 1 2147483647 > (int) 2147483648 U -1 > -2 signed 1 (unsigned) -1 > -2 unsigned 1 232 -1 -1 = 2147483647 EECS 213 Introduction to Computer Systems Northwestern University 13

Sign extension Task: – 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– 2 , …, x 0 k copies of MSB X w • • • X • • • k • • • w EECS 213 Introduction to Computer Systems Northwestern University 14

Sign extension example Converting from smaller to larger integer data type C automatically performs sign extension short int x = 15213; int ix = (int) x; short int y = -15213; int iy = (int) y; x ix y iy Decimal Hex 3 B 15213 00 00 3 B C 4 -15213 FF FF C 4 Binary 6 D 00111011 6 D 00000000 00111011 93 11000100 93 11111111 11000100 EECS 213 Introduction to Computer Systems Northwestern University 01101101 10010011 15

Justification for sign extension Prove correctness by induction on k – Induction Step: extending by single bit maintains value w X X - • • • -+ • • • w+1 – Key observation: – 2 w +2 w– 1 = – Look at weight of upper bits: • X’ – 2 w– 1 xw– 1 – 2 w xw– 1 + 2 w– 1 xw– 1 = – 2 w– 1 xw– 1 EECS 213 Introduction to Computer Systems Northwestern University 16

Why should I use unsigned? Don’t use just because number nonzero – C compilers on some machines generate less efficient code – Easy to make mistakes (e. g. , casting) – Few languages other than C supports unsigned integers Do use when need extra bit’s worth of range – Working right up to limit of word size EECS 213 Introduction to Computer Systems Northwestern University 17

Negating with complement & increment Claim: Following holds for 2’s complement – ~x + 1 == -x Complement – Observation: ~x + x == 1111… 112 == -1 Increment x 1001 110 1 + ~x 0110 001 0 -1 111 1 – ~x + (-x + 1) == -1 + (-x + 1) – ~x + 1 == -x EECS 213 Introduction to Computer Systems Northwestern University 18

Comp. & incr. examples x = 15213 0 EECS 213 Introduction to Computer Systems Northwestern University 19

Unsigned addition Standard addition function – Ignores carry output Implements modular arithmetic – s = UAddw(u , v) = u + v mod 2 w u • • • v • • • u+v • • • UAddw(u , v) • • • Operands: w bits + True Sum: w+1 bits Discard Carry: w bits EECS 213 Introduction to Computer Systems Northwestern University 20

Visualizing integer addition Integer addition – – 4 -bit integers u, v Compute true sum Add 4(u , v) Values increase linearly with u and v Forms planar surface Add 4(u , v) v u EECS 213 Introduction to Computer Systems Northwestern University 21

Visualizing unsigned addition Wraps around Overflow – If true sum ≥ 2 w – At most once True Sum 2 w+1 UAdd 4(u , v) Overflow 2 w 0 v Modular Sum u EECS 213 Introduction to Computer Systems Northwestern University 22

Two’s complement addition 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 u • • • v • • • u+v • • • TAddw(u , v) • • • Operands: w bits + True Sum: w+1 bits Discard Carry: w bits EECS 213 Introduction to Computer Systems Northwestern University 23

Characterizing TAdd Functionality – True sum requires w+1 bits – Drop off MSB – Treat remaining bits as 2’s comp. integer True Sum 0 111… 1 2 w– 1 Pos. Over TAdd Result 0 100… 0 2 w – 1 011… 1 0 000… 0 1 100… 0 – 2 w – 1 1 000… 0 – 2 w 100… 0 Neg. Over (Neg. Over) (Pos. Over) EECS 213 Introduction to Computer Systems Northwestern University 24

Visualizing 2’s comp. addition Values – 4 -bit two’s comp. – Range from -8 to +7 Wraps Around TAdd 4(u , v) – If sum 2 w– 1 Neg. Over • Becomes negative • At most once – If sum < – 2 w– 1 • Becomes positive • At most once v Pos. Over u EECS 213 Introduction to Computer Systems Northwestern University 25

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 u, v < 0, s 0 u, v 0, s < 0 Pos. Over 2 w – 1 0 Neg. Over – Overflow iff either: • • 2 w– 1 (Neg. Over) (Pos. Over) ovf = (u<0 == v<0) && (u<0 != s<0); EECS 213 Introduction to Computer Systems Northwestern University 26

Multiplication Computing exact product of w-bit numbers x, y – Either signed or unsigned Ranges – Unsigned: 0 ≤ x * y ≤ (2 w – 1) 2 = 22 w – 2 w+1 + 1 • May need up to 2 w bits to represent – Two’s complement min: x * y ≥ (– 2 w– 1)*(2 w– 1– 1) = – 22 w– 2 + 2 w – 1 • Up to 2 w– 1 bits – Two’s complement max: x * y ≤ (– 2 w– 1) 2 = 22 w– 2 • Up to 2 w bits Maintaining exact results – Would need to keep expanding word size with each product computed – Done in software by “arbitrary precision” arithmetic packages EECS 213 Introduction to Computer Systems Northwestern University 27

Unsigned multiplication in C Operands: w bits True Product: 2*w bits u·v Discard w bits: w bits * u • • • v • • • UMultw(u , v) • • • Standard multiplication function – Ignores high order w bits Implements modular arithmetic UMultw(u , v) = u · v mod 2 w EECS 213 Introduction to Computer Systems Northwestern University 28

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 2 w 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) EECS 213 Introduction to Computer Systems Northwestern University 29

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 EECS 213 Introduction to Computer Systems Northwestern University 30

Power-of-2 multiply with shift Operation – u << k gives u * 2 k – Both signed and unsigned Operands: w bits True Product: w+k bits Discard k bits: w bits Examples * u · 2 k u k • • • 2 k 0 • • • 0 1 0 • • • 0 0 • • • UMultw(u , 2 k) • • • 0 • • • 0 0 TMultw(u , 2 k) – 3*a = a<<1 + a – Most machines shift and add much faster than multiply (1 to +12 cycles) • Compiler generates this code automatically EECS 213 Introduction to Computer Systems Northwestern University 31

Unsigned power-of-2 divide with shift Quotient of unsigned by power of 2 – u >> k gives u / 2 k – Uses logical shift k Operands: Division: Result: u / • • • 2 k Binary Point • • • 0 • • • 0 1 0 • • • 0 0 u / 2 k 0 • • • u / 2 k 0 • • • EECS 213 Introduction to Computer Systems Northwestern University . • • • 32

Signed power-of-2 divide with shift Quotient of signed by power of 2 – x >> k gives x / 2 k – Uses arithmetic shift – Rounds wrong direction when u < 0 k Operands: Division: Result: x / • • • 2 k Binary Point • • • 0 • • • 0 1 0 • • • 0 0 x / 2 k Round. Down(x / 2 k) 0 • • • EECS 213 Introduction to Computer Systems Northwestern University . • • • 33

Correct power-of-2 divide Quotient of negative number by power of 2 – Want x / 2 k (Round Toward 0) – Compute as (x+2 k-1)/ 2 k • In C: (x<0 ? (x + (1<<k)-1) : x) >> k • Biases dividend toward 0 Case 1: No rounding Dividend: u 1 +2 k +– 1 / • • • 0 • • • 0 0 1 • • • 1 1 1 Divisor: k 2 k • • • 1 • • • 1 1 Binary Point 0 • • • 0 1 0 • • • 0 0 u / 2 k 0 • • • 1 1 • • • . 1 • • • 1 1 Biasing has no effect EECS 213 Introduction to Computer Systems Northwestern University 34

Correct power-of-2 divide (Cont. ) Case 2: Rounding k Dividend: x +2 k +– 1 1 • • • 0 • • • 0 0 1 • • • 1 1 1 • • • Incremented by 1 Divisor: / 2 k x / 2 k Binary Point 0 • • • 0 1 0 • • • 0 0 0 • • • 1 1 Biasing adds 1 to final result • • • Incremented by 1 EECS 213 Introduction to Computer Systems Northwestern University 35

C Puzzle answers Assume machine with 32 bit word size, two’s comp. integers TMin makes a good counterexample in many cases False: TMin True: 0 = UMin True: x 1 = 1 False: 0 False: -1, TMin False: 30426 x + y > 0 False: TMax, TMax -x <= 0 True: –TMax < 0 -x >= 0 False: TMin q x < 0 q ux >= 0 q x & 7 == 7 q ux > -1 q x > y q x * x >= 0 q x > 0 && y > 0 q x >= 0 q x <= 0 ((x*2) < 0) (x<<30) < 0 -x < -y EECS 213 Introduction to Computer Systems Northwestern University 36