15-213 “the course that gives cmu its zip!” topics basic operations –addition, negation,...

15-213“The course that gives CMU its

Zip!”

Topics• Basic operations

– Addition, negation, multiplication

• Programming Implications

– Consequences of overflow

– Using shifts to perform power-of-2 multiply/divide

CS 213 F’98class04.ppt

Integer Arithmetic OperationsSept. 3, 1998

CS 213 F’98– 2 –class04.ppt

C Puzzles• Taken from Exam #2, CS 347, Spring ‘97

• 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

int x = foo();

int y = bar();

unsigned ux = x;

unsigned uy = y;

Initialization


Unsigned Addition

Standard Addition Function• Ignores carry output

Implements Modular Arithmetics = UAddw(u , v) = u + v mod

2w

• • •

• • •

u

v+

• • •u + v

• • •

True Sum: w+1 bits

Operands: w bits

Discard Carry: w bits UAddw(u , v)


0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15

0

2

4

6

8

10

12

14

0

5

10

15

20

25

30

Visualizing Integer AdditionInteger Addition

• 4-bit integers u and v

• Compute true sum Add4(u , v)

• Values increase linearly with u and v

• Forms planar surface

Add4(u , v)

u

v


0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15

0

2

4

6

8

10

12

14

0

2

4

6

8

10

12

14

16

Visualizing Unsigned AdditionWraps Around

• If true sum ≥ 2w

• At most once

0

2w

2w+1

UAdd4(u , v)

u

v

True Sum

Modular Sum

Overflow

Overflow


Mathematical PropertiesModular Addition Forms an Abelian Group

• Closed under addition

0 ≤ UAddw(u , v) ≤ 2w –1

• Commutative

UAddw(u , v) = UAddw(v , u)

• Associative

UAddw(t, UAddw(u , v)) = UAddw(UAddw(t, u ), v)

• 0 is additive identity

UAddw(u , 0) = u

• Every element has additive inverse

– Let UCompw (u ) = 2w – u

UAddw(u , UCompw (u )) = 0


Detecting Unsigned OverflowTask

• Given s = UAddw(u , v)

• Determine if s = u + v

Applicationunsigned s, u, v;

s = u + v;• Did addition overflow?

Claim• Overflow iff s < u

ovf = (s < u)• Or symmetrically iff s < v

Proof• Know that 0 ≤ v < 2w

• No overflow ==> s = u + v ≥ u + 0 = u

• Overflow ==> s = u + v – 2w < u + 0 = u

u v

2w

s

u v

2w

s

No Overflow

Overflow


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

• • •

True Sum: w+1 bits

Operands: w bits

Discard Carry: w bits TAddw(u , v)


Characterizing TAddFunctionality

• True sum requires w+1 bits

• Drop off MSB

• Treat remaining bits as 2’s comp. integer

–2w –1

–2w

0

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

NegOver

(NegOver)

(PosOver)

u

v

< 0 > 0

< 0

> 0

NegOver

PosOverTAdd(u , v)

CS 213 F’98– 10 –class04.ppt

-8 -7 -6 -5 -4 -3 -2 -1 0 1 2 3 4 5 6 7

-8

-6

-4

-2

0

2

4

6

-8

-6

-4

-2

0

2

4

6

8

Visualizing 2’s Comp. Addition

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

– At most once

TAdd4(u , v)

uv

PosOver

NegOver

CS 213 F’98– 11 –class04.ppt

Detecting 2’s Comp. OverflowTask

• 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);

Proof• Easy to see that if u ≥ 0 and v < 0, then TMinw ≤ u +v ≤ TMaxw

• Symmetrically if u < 0 and v ≥ 0

• Other cases from analysis of TAdd

0

2w –1

2w–1PosOver

NegOver

CS 213 F’98– 12 –class04.ppt

Mathematical Properties of TAddIsomorphic Algebra to UAdd

• TAddw(u , v) = U2T(UAddw(T2U(u ), T2U(v)))

– Since both have identical bit patterns

Two’s Complement Under TAdd Forms a Group• Closed, Commutative, Associative, 0 is additive identity

• Every element has additive inverse

– Let TCompw (u ) = U2T(UCompw(T2U(u ))

TAddw(u , TCompw (u )) = 0

TCompw(u) =−u u≠TMinwTMinw u=TMinw

⎧⎨⎩

CS 213 F’98– 13 –class04.ppt

Two’s Complement NegationMostly like Integer Negation

• TComp(u) = –u

TMin is Special Case• TComp(TMin) = TMin

Negation in C is Actually TComp mx = -x

• mx = TComp(x)

• Computes additive inverse for TAdd

x + -x == 0

1000

1001

1010

1011

1100

1101

1110

1111

0000

0001

0010

0011

0100

0101

0110

0111

–2w–1

2w–1

–2w–1

2w–1

u

Tcomp(u )

CS 213 F’98– 14 –class04.ppt

Negating with Complement & IncrementIn C

~x + 1 == -x

Complement• Observation: ~x + x == 1111…112 == -1

Increment• ~x + x + (-x + 1) == -1 + (-x + 1)• ~x + 1 == -x

Warning: Be cautious treating int’s as integers• OK here: We are using group properties of TAdd and TComp

1 0 0 1 0 11 1 x

0 1 1 0 1 00 0~x+

1 1 1 1 1 11 1-1

CS 213 F’98– 15 –class04.ppt

Comp. & Incr. Examples

Decimal Hex BinaryTMin -32768 80 00 10000000 00000000~TMin 32767 7F FF 01111111 11111111~TMin+1 -32768 80 00 10000000 00000000

Decimal Hex Binaryx 15213 3B 6D 00111011 01101101~x -15214 C4 92 11000100 10010010~x+1 -15213 C4 93 11000100 10010011y -15213 C4 93 11000100 10010011

TMin

x = 15213

Decimal Hex Binary0 0 00 00 00000000 00000000~0 -1 FF FF 11111111 11111111~0+1 0 00 00 00000000 00000000

0

CS 213 F’98– 16 –class04.ppt

Comparing Two’s Complement NumbersTask

• Given signed numbers u, v

• Determine whether or not u > v

– Return 1 for numbers in shaded region below

Bad Approach• Test (u–v) > 0

– TSub(u,v) = TAdd(u, TComp(v))

• Problem: Thrown off by either Negative or Positive Overflow

u

v

< 0 > 0

< 0

> 0

u < v

u > v

u==v

CS 213 F’98– 17 –class04.ppt

-8 -7 -6 -5 -4 -3 -2 -1 0 1 2 3 4 5 6 7-8

-6

-4

-2

0

2

4

6

-8

-6

-4

-2

0

2

4

6

8

Comparing with TSubWill Get Wrong Results

• NegOver: u < 0, v > 0

– but u-v > 0

• PosOver: u > 0, v < 0

– but u-v < 0

u

v

< 0 > 0

< 0

> 0

u-v

+-

-

+

++

-

-

NegOver

PosOver

TSub4(u , v)

u

v

PosOver

NegOver

CS 213 F’98– 18 –class04.ppt

Working Around Overflow ProblemsPartition into Three Regions

• u < 0, v ≥ 0 u < v

u

v

< 0 ≥ 0

< 0

≥ 0 u<0v≥0

• u ≥ 0, v < 0 u > v

• u, v same sign u-v does not overflow

– Can safely use test (u–v) > 0

v

< 0 ≥ 0

< 0

≥ 0

u≥0v<0

u

v

< 0 ≥ 0

< 0

≥ 0

u<0v<0

u≥0v≥0

uu

v

< 0 > 0

< 0

> 0

u-v

+

+-

-

CS 213 F’98– 19 –class04.ppt

MultiplicationComputing Exact Product of w-bit numbers x, y

• 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 TMinw2

Maintaining Exact Results• Would need to keep expanding word size with each product

computed

• Done in software by “arbitrary precision” arithmetic packages

• Also implemented in Lisp, ML, and other “advanced” languages

CS 213 F’98– 20 –class04.ppt

Unsigned Multiplication in C

Standard Multiplication Function• Ignores high order w bits

Implements Modular ArithmeticUMultw(u , v) = u · v mod 2w

• • •

• • •

u

v*

• • •u · v

• • •

True Product: 2*w bits

Operands: w bits

Discard w bits: w bits UMultw(u , v)

• • •

CS 213 F’98– 21 –class04.ppt

Unsigned vs. Signed MultiplicationUnsigned Multiplication

unsigned ux = (unsigned) x;

unsigned uy = (unsigned) y;

unsigned up = ux * uy

• Truncates product to w-bit number up = UMultw(ux, uy)

• Simply modular arithmetic

up = ux uy mod 2w

Two’s Complement Multiplicationint x, y;

int p = x * y;

• Compute exact product of two w-bit numbers x, y

• Truncate result tow-bit number p = TMultw(x, y)

Relation• Signed multiplication gives same bit-level result as unsigned

• up == (unsigned) p

CS 213 F’98– 22 –class04.ppt

x = 15213: 00111011 01101101txx = 231435369: 00001101 11001011 01101100 01101001xx = 27753: 00000000 00000000 01101100 01101001xx2 = -10030: 11111111 11111111 11011000 11010010

short int x = 15213; int txx = ((int) x) * x; int xx = (int) (x * x); int xx2 = (int) (2 * x * x);

Multiplication Examples

Observations• Casting order important

– If either operand int, will perform int multiplication

– If both operands short int, will perform short int multiplication

• Really is modular arithmetic

– Computes for xx: 152132 mod 65536 = 27753– Computes for xx2: (int) 55506U = -10030

• Note that xx2 == (xx << 1)

CS 213 F’98– 23 –class04.ppt

Power-of-2 Multiply with ShiftOperation

• u << k gives same result as u * 2k

• Both signed and unsigned

Examples• u << 3 == u * 8• u << 5 - u << 3 == u * 24

• Most machines shift and add much faster than multiply

– Compiler will generate this code automatically

• • •

0 0 1 0 0 0•••

u

2k*

u · 2kTrue Product: w+k bits

Operands: w bits

Discard k bits: w bits UMultw(u , 2k)

•••

k

• • • 0 0 0•••

TMultw(u , 2k)

0 0 0••••••

CS 213 F’98– 24 –class04.ppt

Unsigned Power-of-2 Divide with ShiftQuotient of Unsigned by Power of 2

• u >> k gives same result as u / 2k • Uses logical shift

0 0 1 0 0 0•••

u

2k/

u / 2kDivision:

Operands:•••

k••• •••

•••0 0 0••• •••

u / 2k •••0 0•••0Quotient:

.

Binary Point

Division Computed Hex Binaryx 15213 15213 3B 6D 00111011 01101101x >> 1 7606.5 7606 1D B6 00011101 10110110x >> 4 950.8125 950 03 B6 00000011 10110110x >> 8 59.4257813 59 00 3B 00000000 00111011

CS 213 F’98– 25 –class04.ppt

2’s Comp Power-of-2 Divide with ShiftQuotient of Signed by Power of 2

• u >> k almost gives same result as u / 2k • Uses arithmetic shift

• Rounds wrong direction when u < 0

0 0 1 0 0 0•••

u

2k/

u / 2kDivision:

Operands:•••

k••• •••

•••0 ••• •••

RoundDown(u / 2k) •••Result:

.

Binary Point

0 •••

Division Computed Hex Binaryy -15213 -15213 C4 93 11000100 10010011y >> 1 -7606.5 -7607 E2 49 11100010 01001001y >> 4 -950.8125 -951 FC 49 11111100 01001001y >> 8 -59.4257813 -60 FF C4 11111111 11000100

CS 213 F’98– 26 –class04.ppt

Properties of Unsigned ArithmeticUnsigned Multiplication with Addition Forms

Commutative Ring• Addition is commutative group

• Closed under multiplication

0 ≤ UMultw(u , v) ≤ 2w –1

• Multiplication Commutative

UMultw(u , v) = UMultw(v , u)

• Multiplication is Associative

UMultw(t, UMultw(u , v)) = UMultw(UMultw(t, u ), v)

• 1 is multiplicative identity

UMultw(u , 1) = u

• Multiplication distributes over addtion

UMultw(t, UAddw(u , v)) = UAddw(UMultw(t, u ), UMultw(t, v))

CS 213 F’98– 27 –class04.ppt

Properties of Two’s Comp. ArithmeticIsomorphic Algebras

• Unsigned multiplication and addition

– Truncating to w bits

• Two’s complement multiplication and addition

– 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 + v > v

u > 0, v > 0 u · v > 0

• These properties are not obeyed by two’s complement arithmetic

TMax + 1 == TMin

15213 * 30426 == -10030

CS 213 F’98– 28 –class04.ppt

C Puzzle Answers• Assume machine with 32 bit word size, two’s complement integers

• TMin makes a good counterexample in many cases

• 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: 30426

• x > 0 && y > 0 x + y > 0 False: TMax, TMax

• x >= 0 -x <= 0 True: –TMax < 0

• x <= 0 -x >= 0 False: TMin

15-213 “the course that gives cmu its zip!” topics basic operations –addition, negation,...

Documents