Integers II - PowerPoint Presentation

407 views
Uploaded On 2017-09-11

Integers II - PPT Presentation

CSE 351 Spring 2017 Instructor Ruth Anderson Teaching Assistants Dylan Johnson Kevin Bi Linxing Preston Jiang Cody Ohlsen Yufang Sun Joshua Curtis httpxkcdcom571 Administrivia ID: 587054

0000 1111 unsigned bit 1111 0000 bit unsigned signed shift arithmetic sign int amp complement values overflow 1000 two

Link:

Copy

Embed:

<iframe width="560" height="315" src="https://www.docslides.com/embed/587054" frameborder="0" allowfullscreen></iframe>

Download Presentation from below link

Download Presentation The PPT/PDF document "Integers II" is the property of its rightful owner. Permission is granted to download and print the materials on this web site for personal, non-commercial use only, and to display it on your personal computer provided you do not modify the materials and that you retain all copyright notices contained in the materials. By downloading content from our website, you accept the terms of this agreement.

Presentation Transcript

Slide1

Integers IICSE 351 Spring 2017

Instructor: Ruth AndersonTeaching Assistants:Dylan JohnsonKevin BiLinxing Preston JiangCody OhlsenYufang SunJoshua Curtis

http://xkcd.com/571/ Slide2

AdministriviaSection Tomorrow:

Do not need your computerReminder: Room changes for 9:30 and 10:30 sections!!Activities to help you with Lab 1Lab 1 due next Friday (4/14)Prelim submission (3+ of bits.c) due on Monday (4/10)Bonus slides at the end of today’s lecture have relevant examples2Slide3

IntegersBinary representation of integers

Unsigned and signedCasting in CConsequences of finite width representationsOverflow, sign extensionShifting and arithmetic operations3Slide4

Two’s Complement Arithmetic

The same addition procedure works for both unsigned and two’s complement integersSimplifies hardware: only one algorithm for additionAlgorithm: simple addition, discard the highest carry bitCalled modular addition: result is sum modulo 4-bit Examples: 4

4+3

0100

+0011

-4

1100

+0011

-3

0100

+1101

=-1

=1Slide5

Why Does Two’s Complement Work?

For all representable positive integers , we want:What are the 8-bit negative encodings for the following? 5bit representation of –

bit representation of –

(ignoring the carry-out bit)

00000001

????????

00000000

00000010

????????

00000000

11000011

????????

00000000Slide6

Why Does Two’s Complement Work?

For all representable positive integers , we want:What are the 8-bit negative encodings for the following? 6bit representation of –

bit representation of –

(ignoring the carry-out bit)

00000001

11111111

00000000

00000010

11111110

00000000

11000011+ 00111101

00000000

These are the bitwise complement plus 1!

-x == ~x + 1Slide7

UMax

– 1

TMax

TMin

–1

–2

UMax

TMax

+ 1

2’s Complement Range

Unsigned

Range

Signed/Unsigned Conversion Visualized

Two’s Complement

Unsigned

Ordering Inversion

Negative

Big

Positive

7Slide8

Values To Remember

Unsigned ValuesUMin = 0b00…0 = UMax = 0b11…1 = Example: Values for 8Two’s Complement Values

TMin = 0b10…0 =

TMax

0b01…1

0b11…1

Decimal

Hex

UMax

18,446,

744,073,709,551,615

FF FF FF FF FF FF FF FFTMax9,223,372,036,854,775,8077F FF FF FF FF FF FF FF

TMin

-9,223,372,036,854,775,808

80 00 00 00

00 00 00 00

-1

FF FF

00 00 00 00 00

00 00 00Slide9

In C: Signed vs. UnsignedCasting

Bits are unchanged, just interpreted differently! int tx, ty;unsigned int ux, uy;Explicit castingtx = (int) ux;uy = (unsigned int) ty;Implicit casting can occur during assignments or function callstx = ux;uy = ty;

9Slide10

Casting SurprisesInteger literals (constants)By default,

integer constants are considered signed integersHex constants already have an explicit binary representationUse “U” (or “u”) suffix to explicitly force unsignedExamples: 0U, 4294967259uExpression EvaluationWhen you mixed unsigned and signed in a single expression, then signed values are implicitly cast to unsignedIncluding comparison operators <, >, ==, <=, >=10!!!Slide11

Casting Surprises32-bit examples:

TMin = -2,147,483,648, TMax = 2,147,483,64711!!!Constant1

Constant2

Interpretation

of bits

Relation

0000 0000 0000 0000 0000 0000 0000 0000

Unsigned

-1

1111 1111 1111 1111 1111 1111 1111 1111

00000 0000 0000 0000 0000 0000 0000 0000

Signed

-1

1111 1111 1111 1111 1111 1111 1111 1111

0000 0000 0000 0000 0000 0000 0000 0000

Unsigned

2147483647

0111 1111 1111 1111 1111 1111 1111 1111

-2147483648

1000 0000 0000 0000 0000 0000 0000 0000

Signed

2147483647

0111 1111 1111 1111 1111 1111 1111 1111

-2147483648

1000 0000 0000 0000 0000 0000 0000 0000

Unsigned

-1

1111 1111 1111 1111 1111 1111 1111 1111

-2

1111 1111 1111 1111 1111 1111 1111 1110

Signed

(unsigned)

-1

1111 1111 1111 1111 1111 1111 1111 1111

-2

1111 1111 1111 1111 1111 1111 1111 1110

Unsigned

2147483647

0111 1111 1111 1111 1111 1111 1111 1111

2147483648

1000 0000 0000 0000 0000 0000 0000 0000

Unsigned

2147483647

0111 1111 1111 1111 1111 1111 1111 1111

(

int

) 2147483648

1000 0000 0000 0000 0000 0000 0000 0000

Signed

REMINDER: If

you mix

signed

and

unsigned,

signed

values are implicitly

cast

unsigned

Casting (implicit or explicit) does NOT change

the bits. The bits

are just interpreted differently

. Slide12

IntegersBinary representation of integersUnsigned

and signedCasting in CConsequences of finite width representationsOverflow, sign extensionShifting and arithmetic operations12Slide13

Arithmetic Overflow

Arithmetic Overflow - when a calculation produces a result that can’t be represented in the current encoding schemeInteger range limited by fixed widthCan occur in both the positive and negative directionsC and Java ignore overflow exceptionsYou end up with a bad value in your program and no warning/indication… oops!13BitsUnsigned

Signed

0000

0001

0010

0011

01004401015

0110

0111

1000

-8

1001

-7

1010

-6

1011

-5

1100

-4

1101

-3

1110

-2

1111

-1Slide14

Overflow: Unsigned

Addition: drop carry bit ()Subtraction: borrow () 1415+ 2171

1111+ 0010

0001

0000

0001

0011

1111

1110

1100

1011

1010

1000

0111

01100100001001011001

1101

Unsigned

-1

0001

0010

1111

because of

odular arithmetic

Slide15

Overflow: Two’s Complement

Addition: () + () = () result?Subtraction: () + () = ()? 15

0000

0001

0011

1111

1110

1100

1011

1010

1000

0111

0110

0100

0010

0101100111010+ 1+ 2

+ 3

+ 4

+ 5

+ 6

+ 7

– 8

– 7

– 6

– 5

– 4

– 3

– 2

– 1

For signed:

overflow if operands have same sign and result’s sign is different

Two’s

Complement

-7

0110

+ 0011

1001

-7

-10

1001

0011

0110Slide16

Sign Extension

What happens if you convert a signed integral data type to a larger one?e.g. char short int long4-bit 8-bit Example:Positive CaseAdd 0’s? 16

4-bit:

0010

8-bit:

????

0010

0000

0010

✓Slide17

QuestionWhich of the following 8-bit numbers has the same

signed value as the (signed) 4-bit number 0b1100?Underlined digit = MSB0b 0000 11000b 1000 11000b 1111 11000b 1100 110017Slide18

Sign Extension

Task: Given a -bit signed integer , convert it to +-bit signed integer with the same valueRule: Add copies of sign bitLet be the -th

digit of in binary

copies of MSB

• • •

riginal

Slide19

Sign Extension Example

Convert from smaller to larger integral data typesC automatically performs sign extension Java too19short int x = 12345;int ix = (int) x;

short int y =

12345

;

int

= (

int

) y;

Var

Decimal

Hex

Binaryx12345

30 39

00110000 00111001

12345

00 00 30 39

00000000 00000000 00110000 00111001

-12345

CF C7

11001111 11000111

-12345

CF C7

11111111 11111111 11001111 11000111Slide20

IntegersBinary representation of integersU

nsigned and signedCasting in CConsequences of finite width representationsOverflow, sign extensionShifting and arithmetic operations20Slide21

Shift OperationsLeft shift (

x<<n) bit vector x by n positionsThrow away (drop) extra bits on leftFill with 0s on rightRight shift (x>>n) bit-vector x by n positionsThrow away (drop) extra bits on rightLogical shift (for unsigned values)Fill with 0s on leftArithmetic shift (for signed values)Replicate most significant bit on leftMaintains sign of x21Slide22

Shift Operations

Left shift (x<<n)Fill with 0s on rightRight shift (x>>n)Logical shift (for unsigned values)Fill with 0s on leftArithmetic shift (for signed values)Replicate most significant bit on leftNotes:Shifts by n<0 or nw (bit width of x) are undefinedIn C: behavior of >> is determined by compilerIn gcc / C lang, depends on data type of x (signed/unsigned)In Java: logical shift is >>>

and arithmetic shift is >>

0010 0010

x<<3

0001 0

000

logical:

x>>2

00 1000

arithmetic:

x>>2

00 1000

1010 0010

x<<3

0001 0

000

logical:

x>>2

0 1000

arithmetic:

x>>2

0 1000Slide23

Shifting Arithmetic?What are the following computing?

x>>n0b 0100 >> 1 = 0b 00100b 0100 >> 2 = 0b 0001Divide by 2nx<<n0b 0001 << 1 = 0b 00100b 0001 << 2 = 0b 0100Multiply by 2nShifting is faster than general multiply and divide operations23Slide24

Left Shifting Arithmetic 8-bit ExampleNo difference in left shift operation for unsigned and signed numbers (just manipulates bits)

Difference comes during interpretation: x*2n?24x = 25; 00011001 =L1=x<<2; 0001100100 =L2=x<<3; 00011001

000 =L

3=x<<4;

0001

1001

0000

25 25

100 100

-56 200

-112 144

Signed Unsigned

signed overflow

unsigned overflow

signed overflowSlide25

Right Shifting 8-bit ExamplesReminder: C operator

>> does logical shift on unsigned values and arithmetic shift on signed valuesLogical Shift: x/2n?25xu = 240u; 11110000 =R1u=xu>>3; 00011110000

=R2u=

>>5;

00000

111

10000

240

rounding (down)Slide26

Right Shifting 8-bit ExamplesReminder: C operator

>> does logical shift on unsigned values and arithmetic shift on signed valuesArithmetic Shift: x/2n?26xs = -16; 11110000 =R1s=xu>>3; 11111110000

=R2s=

>>5;

11111

111

10000

-16

-2

-1

rounding (down)Slide27

Question

Assume we are using 8-bit arithmetic:x == (unsigned char) xx >= 128Ux != (x>>2)<<2x == -x Hint: there are two solutions(x < 128U) && (x > 0x3F)27

For the following expressions, find a value of signed char x

, if there exists one, that makes the expression

TRUE

. Compare

with your neighbor(s

)!Slide28

Question

Assume we are using 8-bit arithmetic:x == (unsigned char) xx >= 128Ux != (x>>2)<<2x == -x Hint: there are two solutions(x < 128U) && (x > 0x3F)28

For the following expressions, find a value of signed char x

, if there exists one, that makes the expression

TRUE

. Compare

with your neighbor(s

)!Slide29

Summary

Sign and unsigned variables in CBit pattern remains the same, just interpreted differentlyStrange things can happen with our arithmetic when we convert/cast between sign and unsigned numbersType of variables affects behavior of operators (shifting, comparison)We can only represent so many numbers in bitsWhen we exceed the limits, arithmetic overflow occursSign extension tries to preserve value when expandingShifting is a useful bitwise operatorRight shifting can be arithmetic (sign) or logical (0)Can be used in multiplication with constant or bit masking 29Slide30

Some examples of using shift operators in combination with bitmasks, which you may find helpful for Lab 1. We will try to cover these in lecture or section if we have the time.

Extract the 2nd most significant byte of an intExtract the sign bit of a signed intConditionals as Boolean expressions30BONUS SLIDESSlide31

Using Shifts and MasksExtract the 2

nd most significant byte of an int:First shift, then mask: (x>>16) & 0xFFOr first mask, then shift: (x & 0xFF0000)>>16310xFF

00000000

11111111

(x>>16) & 0xFF

00000000

00000010

x>>16

00000000

00000001

00000010

00000001

00000010

00000011

00000100

x & 0xFF0000

00000000

00000010

00000000

(x&0xFF0000)>>16

00000000

00000010

0xFF0000

00000000

11111111

00000000

00000001

00000010

00000011

00000100Slide32

Using Shifts and MasksExtract the sign bit

of a signed int:First shift, then mask: (x>>31) & 0x1Assuming arithmetic shift here, but this works in either caseNeed mask to clear 1s possibly shifted in32x

00000001

00000010

00000011

00000100

x>>31

00000000

0x1

00000000

00000001

(x>>31) & 0x1

00000000

10000001

00000010

00000011

00000100

x>>31

11111111

0x1

00000000

00000001

(x>>31) & 0x1

00000000

00000001

1Slide33

Using Shifts and MasksConditionals as Boolean expressions

For int x, what does (x<<31)>>31 do?Can use in place of conditional:In C: if(x) {a=y;} else {a=z;} equivalent to a=x?y:z;a=(((x<<31)>>31)&y) | (((!x<<31)>>31)&z);33

x=!!123

00000000

0000000

x<<31

0000000

00000000

(x<<31)>>31

11111111

00000000

0000000

!x<<31

0000000