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
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.
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
+3
1100
+0011
4
-3
0100
+1101
=7
=-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
1
00000000
00000010
+
11111110
1
00000000
11000011+ 00111101
1
00000000
These are the bitwise complement plus 1!
-x == ~x + 1Slide7
UMax
– 1
0
TMax
TMin
–1
–2
0
UMax
TMax
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
-1
FF FF
FF
FF
FF
FF
FF
FF
0
0
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
0
0000 0000 0000 0000 0000 0000 0000 0000
0
U
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
0
U
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
U
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
U
1000 0000 0000 0000 0000 0000 0000 0000
Unsigned
<
2147483647
0111 1111 1111 1111 1111 1111 1111 1111
(
int
) 2147483648
U
1000 0000 0000 0000 0000 0000 0000 0000
Signed
>
REMINDER: If
you mix
signed
and
unsigned,
signed
values are implicitly
cast
to
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
0
0
0001
1
1
0010
2
2
0011
3
3
01004401015
5
0110
6
6
0111
7
7
1000
8
-8
1001
9
-7
1010
10
-6
1011
11
-5
1100
12
-4
1101
13
-3
1110
14
-2
1111
15
-1Slide14
Overflow: Unsigned
Addition: drop carry bit ()Subtraction: borrow () 1415+ 2171
1111+ 0010
1
0001
0000
0001
0011
1111
1110
1100
1011
1010
1000
0111
01100100001001011001
1101
0
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
Unsigned
1
-
2
-1
15
1
0001
-
0010
1111
because of
m
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
6
+
3
9
-7
0110
+ 0011
1001
-7
-
3
-10
6
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
=
+2
8-bit:
????
0010
=
?
0000
0010
+2
✓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
18
copies of MSB
• • •
• • •
• • •
• • •
o
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
iy
= (
int
) y;
Var
Decimal
Hex
Binaryx12345
30 39
00110000 00111001
ix
12345
00 00 30 39
00000000 00000000 00110000 00111001
y
-12345
CF C7
11001111 11000111
iy
-12345
FF
FF
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 >>
22
x
0010 0010
x<<3
0001 0
000
logical:
x>>2
00
00 1000
arithmetic:
x>>2
00
00 1000
x
1010 0010
x<<3
0001 0
000
logical:
x>>2
00
1
0 1000
arithmetic:
x>>2
11
1
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=
xu
>>5;
00000
111
10000
=
240
30
7
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=
xu
>>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
00000000
00000000
11111111
(x>>16) & 0xFF
00000000
00000000
00000000
00000010
x>>16
00000000
00000000
00000001
00000010
x
00000001
00000010
00000011
00000100
x & 0xFF0000
00000000
00000010
00000000
00000000
(x&0xFF0000)>>16
00000000
00000000
00000000
00000010
0xFF0000
00000000
11111111
00000000
00000000
x
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
00000000
00000000
00000000
0x1
00000000
00000000
00000000
00000001
(x>>31) & 0x1
00000000
00000000
00000000
00000000
x
10000001
00000010
00000011
00000100
x>>31
11111111
11111111
11111111
11111111
0x1
00000000
00000000
00000000
00000001
(x>>31) & 0x1
00000000
00000000
00000000
00000001
0
0
1
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
00000000
00000000
0000000
1
x<<31
1
0000000
00000000
00000000
00000000
(x<<31)>>31
11111111
11111111
11111111
11111111
!x
00000000
00000000
00000000
0000000
0
!x<<31
0
0000000
00000000
00000000
00000000
(!x<<31)>>31
00000000
00000000
00000000
00000000