Presentation is loading. Please wait.

Presentation is loading. Please wait.

February 4, 2003 CSCE 212 Computer Architecture Lecture 3 Representing Integers.

Published by Modified over 8 years ago

Similar presentations

Presentation on theme: "February 4, 2003 CSCE 212 Computer Architecture Lecture 3 Representing Integers."— Presentation transcript:

1 February 4, 2003 CSCE 212 Computer Architecture Lecture 3 Representing Integers

2 – 2 – CSCE 212H Sp 03 Bit-Level Operations in C Operations &, |, ~, ^ Available in C Apply to any “integral” data type long, int, short, char View arguments as bit vectors Arguments applied bit-wise Examples (Char data type) ~0x41 --> 0xBE ~01000001 2 -->10111110 2 ~0x00 --> 0xFF ~00000000 2 -->11111111 2 0x69 & 0x55 --> 0x41 01101001 2 & 01010101 2 --> 01000001 2 0x69 | 0x55 --> 0x7D 01101001 2 | 01010101 2 --> 01111101 2

3 – 3 – CSCE 212H Sp 03 Contrast: Logic Operations in C Contrast to Logical Operators &&, ||, ! View 0 as “False” Anything nonzero as “True” Always return 0 or 1 Early termination Examples (char data type) !0x41 --> 0x00 !0x00 --> 0x01 !!0x41 --> 0x01 0x69 && 0x55 --> 0x01 0x69 || 0x55 --> 0x01 p && *p ( avoids null pointer access)

4 – 4 – CSCE 212H Sp 03 Shift Operations Left Shift: x << y Shift bit-vector x left y positions Throw away extra bits on left Fill with 0’s on right Right Shift: x >> y Shift bit-vector x right y positions Throw away extra bits on right Logical shift Fill with 0’s on left Arithmetic shift Replicate most significant bit on right Useful with two’s complement integer representation

5 – 5 – CSCE 212H Sp 03 XOR Bitwise Xor is form of addition With extra property that every value is its own additive inverse A ^ A = 0 void funny(int *x, int *y) { *x = *x ^ *y; /* #1 */ *x = *x ^ *y; /* #1 */ *y = *x ^ *y; /* #2 */ *y = *x ^ *y; /* #2 */ *x = *x ^ *y; /* #3 */ *x = *x ^ *y; /* #3 */}

6 – 6 – CSCE 212H Sp 03 C Integer Puzzles 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 int x = foo(); int y = bar(); unsigned ux = x; unsigned uy = y; Initialization

7 – 7 – CSCE 212H Sp 03 Encoding Integers short int x = 15213; short int y = -15213; C short 2 bytes long Sign Bit For 2’s complement, most significant bit indicates sign 0 for nonnegative 1 for negative Unsigned Two’s Complement Sign Bit

8 – 8 – CSCE 212H Sp 03 Encoding Example (Cont.) x = 15213: 00111011 01101101 y = -15213: 11000100 10010011

9 – 9 – CSCE 212H Sp 03 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 – 1 011…1 Other Values Minus 1 111…1 Values for W = 16

10 – 10 – CSCE 212H Sp 03 Values for Different Word Sizes Observations |TMin | = TMax + 1 Asymmetric range UMax=2 * TMax + 1 C Programming #include K&R App. B11 Declares constants, e.g., ULONG_MAX LONG_MAX LONG_MIN Values platform-specific

11 – 11 – CSCE 212H Sp 03 short int x = 15213; unsigned short int ux = (unsigned short) x; short int y = -15213; unsigned short int uy = (unsigned short) y; Casting Signed to Unsigned C Allows Conversions from Signed to Unsigned Resulting Value No change in bit representation Nonnegative values unchanged ux = 15213 Negative values change into (large) positive values uy = 50323

12 – 12 – CSCE 212H Sp 03 Relation Between Signed & Unsigned uy = y + 2 * 32768=y + 65536

13 – 13 – CSCE 212H Sp 03 Signed vs. Unsigned in C Constants By default are considered to be signed integers Unsigned if have “U” as suffix 0U, 4294967259UCasting Explicit casting between signed & unsigned int tx, ty; unsigned ux, uy; tx = (int) ux; uy = (unsigned) ty; Implicit casting also occurs via assignments and procedure calls tx = ux; uy = ty;

14 – 14 – CSCE 212H Sp 03 00U== unsigned -10< signed -10U> unsigned 2147483647-2147483648 > signed 2147483647U-2147483648 < unsigned -1-2 > signed (unsigned) -1-2 > unsigned 2147483647 2147483648U < unsigned 2147483647 (int) 2147483648U > signed 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 Constant 1 Constant 2 RelationEvaluation 00U -10 -10U 2147483647-2147483648 2147483647U-2147483648 -1-2 (unsigned) -1-2 2147483647 2147483648U 2147483647 (int) 2147483648U

15 – 15 – CSCE 212H Sp 03 0 TMax TMin –1 –2 0 UMax UMax – 1 TMax TMax + 1 2’s Comp. Range Unsigned Range Explanation of Casting Surprises 2’s Comp.  Unsigned Ordering Inversion Negative  Big Positive

16 – 16 – CSCE 212H Sp 03 Sign Extension Task: Given w-bit signed integer x Convert it to w+k-bit integer with same valueRule: Make k copies of sign bit: X = x w–1,…, x w–1, x w–1, x w–2,…, x 0 k copies of MSB X X w w k

17 – 17 – CSCE 212H Sp 03 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;

18 – 18 – CSCE 212H Sp 03 Why Should I Use Unsigned? Don’t Use Just Because Numbers Nonnegative C compilers on some machines generate less efficient code unsigned i; for (i = 1; i < cnt; i++) a[i] += a[i-1]; Easy to make mistakes for (i = cnt-2; i >= 0; i--) a[i] += a[i+1]; Do Use When Performing Modular Arithmetic Multiprecision arithmetic Other esoteric stuff Do Use When Need Extra Bit’s Worth of Range Working right up to limit of word size

19 – 19 – CSCE 212H Sp 03 Negating with Complement & Increment Claim: Following Holds for 2’s Complement ~x + 1 == -xComplement Observation: ~x + x == 1111…11 2 == -1Increment ~x + x + (-x + 1)==-1 + (-x + 1) ~x + 1==-x Warning: Be cautious treating int ’s as integers 10010111 x 01101000 ~x+ 11111111

20 – 20 – CSCE 212H Sp 03 Comp. & Incr. Examples x = 15213 0

21 – 21 – CSCE 212H Sp 03 Unsigned Addition Standard Addition Function Ignores carry output Implements Modular Arithmetic s= UAdd w (u, v)=u + v mod 2 w u v + u + v True Sum: w+1 bits Operands: w bits Discard Carry: w bits UAdd w (u, v)

22 – 22 – CSCE 212H Sp 03 Mathematical Properties Modular Addition Forms an Abelian Group Closed under addition 0  UAdd w (u, v)  2 w –1 Commutative UAdd w (u, v) = UAdd w (v, u) Associative UAdd w (t, UAdd w (u, v)) = UAdd w (UAdd w (t, u ), v) 0 is additive identity UAdd w (u, 0) = u Every element has additive inverse Let UComp w (u ) = 2 w – u UAdd w (u, UComp w (u )) = 0

23 – 23 – CSCE 212H Sp 03 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 TAdd w (u, v)

24 – 24 – CSCE 212H Sp 03 Characterizing TAdd Functionality True sum requires w+1 bits Drop off MSB Treat remaining bits as 2’s comp. integer –2 w –1 –2 w 0 2 w –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 PosOver TAdd(u, v)

25 – 25 – CSCE 212H Sp 03 Detecting 2’s Comp. Overflow Task Given s = TAdd w (u, v) Determine if s = Add w (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) overflow = (u<0 == v<0) && (u<0 != s<0); 0 2 w –1 PosOver NegOver

26 – 26 – CSCE 212H Sp 03 Mathematical Properties of TAdd Isomorphic Algebra to UAdd TAdd w (u, v) = U2T(UAdd w (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 TComp w (u ) = U2T(UComp w (T2U(u )) TAdd w (u, TComp w (u )) = 0

27 – 27 – CSCE 212H Sp 03 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 = UMult w (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 = TMult w (x, y)

28 – 28 – CSCE 212H Sp 03 Unsigned Multiplication in C Standard Multiplication Function Ignores high order w bits Implements Modular Arithmetic UMult w (u, v)=u · v mod 2 w u v * u · v True Product: 2*w bits Operands: w bits Discard w bits: w bits UMult w (u, v)

29 – 29 – CSCE 212H Sp 03 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

30 – 30 – CSCE 212H Sp 03 Power-of-2 Multiply with Shift Operation u << k gives u * 2 k Both signed and unsignedExamples u << 3==u * 8 u << 5 - u << 3==u * 24 Most machines shift and add much faster than multiply Compiler generates this code automatically 001000 u 2k2k * u · 2 k True Product: w+k bits Operands: w bits Discard k bits: w bits UMult w (u, 2 k ) k 000 TMult w (u, 2 k ) 000

31 – 31 – CSCE 212H Sp 03 Unsigned Power-of-2 Divide with Shift Quotient of Unsigned by Power of 2 u >> k gives  u / 2 k  Uses logical shift 001000 u 2k2k / u / 2 k Division: Operands: k 0  u / 2 k  Result:. Binary Point 0

32 – 32 – CSCE 212H Sp 03 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 001000 x 2k2k / x / 2 k Division: Operands: k 0 RoundDown(x / 2 k ) Result:. Binary Point 0

33 – 33 – CSCE 212H Sp 03 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 + (1 > k Biases dividend toward 0 Case 1: No rounding Divisor: Dividend: 001000 u 2k2k /  u / 2 k  k 1 000 1 011. Binary Point 1 000111 +2 k +–1 111 1 111 Biasing has no effect

34 – 34 – CSCE 212H Sp 03 Correct Power-of-2 Divide (Cont.) Divisor: Dividend: Case 2: Rounding 001000 x 2k2k /  x / 2 k  k 1 1 011. Binary Point 1 000111 +2 k +–1 1 Biasing adds 1 to final result Incremented by 1

35 – 35 – CSCE 212H Sp 03 Properties of Unsigned Arithmetic Unsigned Multiplication with Addition Forms Commutative Ring Addition is commutative group Closed under multiplication 0  UMult w (u, v)  2 w –1 Multiplication Commutative UMult w (u, v) = UMult w (v, u) Multiplication is Associative UMult w (t, UMult w (u, v)) = UMult w (UMult w (t, u ), v) 1 is multiplicative identity UMult w (u, 1) = u Multiplication distributes over addtion UMult w (t, UAdd w (u, v)) = UAdd w (UMult w (t, u ), UMult w (t, v))

36 – 36 – CSCE 212H Sp 03 Properties of Two’s Comp. Arithmetic Isomorphic 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 2 w 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 comp. arithmetic TMax + 1== TMin 15213 * 30426==-10030 (16-bit words)

Download ppt "February 4, 2003 CSCE 212 Computer Architecture Lecture 3 Representing Integers."

Similar presentations

When NOT to use Unsigned? Don’t Use Just Because Number Nonzero – C compilers on some machines generate less efficient code unsigned i; for (i = 1; i

When NOT to use Unsigned? Don’t Use Just Because Number Nonzero – C compilers on some machines generate less efficient code unsigned i; for (i = 1; i
Fabián E. Bustamante, Spring 2007 Integers Today Numeric Encodings Programming Implications Basic operations Programming Implications Next time Floats.

Fabián E. Bustamante, Spring 2007 Integers Today Numeric Encodings Programming Implications Basic operations Programming Implications Next time Floats.
CS213 Topics Numeric Encodings Unsigned & Two’s complement Programming Implications C promotion rules Basic operations Addition, negation, multiplication.

CS213 Topics Numeric Encodings Unsigned & Two’s complement Programming Implications C promotion rules Basic operations Addition, negation, multiplication.
Bits, Bytes, and Integers August 29, 2007 Topics Representing information as bits Bit-level manipulations Boolean algebra Expressing in C Representations.

Bits, Bytes, and Integers August 29, 2007 Topics Representing information as bits Bit-level manipulations Boolean algebra Expressing in C Representations.
15-213 “The course that gives CMU its Zip!” Topics Numeric Encodings –Unsigned & Two’s complement Programming Implications –C promotion rules CS 213 F’00.

“The course that gives CMU its Zip!” Topics Numeric Encodings –Unsigned & Two’s complement Programming Implications –C promotion rules CS 213 F’00.
15-213 “The course that gives CMU its Zip!” Topics Numeric Encodings –Unsigned & Two’s complement Programming Implications –C promotion rules Basic operations.

“The course that gives CMU its Zip!” Topics Numeric Encodings –Unsigned & Two’s complement Programming Implications –C promotion rules Basic operations.
CS213 Integers Apr 3, 2006 Topics Numeric Encodings

CS213 Integers Apr 3, 2006 Topics Numeric Encodings
15-213 “The course that gives CMU its Zip!” Topics Numeric Encodings Unsigned & Two’s complement Programming Implications C promotion rules Basic operations.

“The course that gives CMU its Zip!” Topics Numeric Encodings Unsigned & Two’s complement Programming Implications C promotion rules Basic operations.
ICS 2005 Instructor: Peter A. Dinda TA: Bin Lin Recitation 2.

ICS 2005 Instructor: Peter A. Dinda TA: Bin Lin Recitation 2.
Carnegie Mellon 1 This Week: Integers Integers  Representation: unsigned and signed  Conversion, casting  Expanding, truncating  Addition, negation,

Carnegie Mellon 1 This Week: Integers Integers  Representation: unsigned and signed  Conversion, casting  Expanding, truncating  Addition, negation,
Topics Numeric Encodings Unsigned & Two’s complement Programming Implications C promotion rules Basic operations Addition, negation, multiplication Programming.

Topics Numeric Encodings Unsigned & Two’s complement Programming Implications C promotion rules Basic operations Addition, negation, multiplication Programming.
Int’s and Integers CENG331: Introduction to Computer Systems 3 rd Lecture Instructor: Erol Sahin Acknowledgement: Most of the slides are adapted from the.

Int’s and Integers CENG331: Introduction to Computer Systems 3 rd Lecture Instructor: Erol Sahin Acknowledgement: Most of the slides are adapted from the.
– 1 – CS 105 Computer Systems Introduction Topics: Class Intro Data Representation CS 105 “Tour of the Black Holes of Computing!” Geoff Kuenning Fall 2015.

– 1 – CS 105 Computer Systems Introduction Topics: Class Intro Data Representation CS 105 “Tour of the Black Holes of Computing!” Geoff Kuenning Fall 2015.
Carnegie Mellon 1 Bryant and O’Hallaron, Computer Systems: A Programmer’s Perspective, Third Edition Bits, Bytes, and Integers MCS-284 : Computer Organization.

Carnegie Mellon 1 Bryant and O’Hallaron, Computer Systems: A Programmer’s Perspective, Third Edition Bits, Bytes, and Integers MCS-284 : Computer Organization.
Carnegie Mellon 1 Bits, Bytes, and Integers Lecture, Jan. 24, 2013 These slides are from website which accompanies the book “Computer.

Carnegie Mellon 1 Bits, Bytes, and Integers Lecture, Jan. 24, 2013 These slides are from website which accompanies the book “Computer.
1 Integer Representations. 2 Outline Encodings –Unsigned and two’s complement Conversions –Signed vs. unsigned –Long vs. short Suggested reading –Chap.

1 Integer Representations. 2 Outline Encodings –Unsigned and two’s complement Conversions –Signed vs. unsigned –Long vs. short Suggested reading –Chap.
Comp Integers Spring 2015 Topics Numeric Encodings

Comp Integers Spring 2015 Topics Numeric Encodings
– 1 – CS 105 Computer Systems Introduction Topics: Staff, text, and policies Lecture topics and assignments Lab rationale CS 105 “Tour of the Black Holes.

– 1 – CS 105 Computer Systems Introduction Topics: Staff, text, and policies Lecture topics and assignments Lab rationale CS 105 “Tour of the Black Holes.
Lecture 2 Representations

Lecture 2 Representations
Lecture 3: Computation and Representation CS 2011 Fall 2014, Dr. Rozier.

Lecture 3: Computation and Representation CS 2011 Fall 2014, Dr. Rozier.

Similar presentations

Ads by Google