1 / 33

Lecture 3

Lecture 3. Bit Operations Floating Point – 32 bits or 64 bits. 1. Bit Operations. Operator. AND & OR | ONE'S COMPLEMENT ~ EXCLUSIVE OR ^ SHIFT (right) >> SHIFT (left) <<. Operation - examples. AND 1 & 1 = 1; 1& 0 = 0

heidi-charles
Download Presentation

Lecture 3

An Image/Link below is provided (as is) to download presentation Download Policy: Content on the Website is provided to you AS IS for your information and personal use and may not be sold / licensed / shared on other websites without getting consent from its author. Content is provided to you AS IS for your information and personal use only. Download presentation by click this link. While downloading, if for some reason you are not able to download a presentation, the publisher may have deleted the file from their server. During download, if you can't get a presentation, the file might be deleted by the publisher.

E N D

Presentation Transcript

  1. Lecture 3 Bit Operations Floating Point – 32 bits or 64 bits 1

  2. Bit Operations Operator • AND & • OR | • ONE'S COMPLEMENT ~ • EXCLUSIVE OR ^ • SHIFT (right) >> • SHIFT (left) << DCO

  3. Operation - examples • AND 1 & 1 = 1; 1& 0 = 0 • OR 1 |1 = 1; 1| 0 = 1; 0|0 = 0 • ~ 0 =~1; 1 =~0; • ^ 0^ 0 = 0; 1^1 = 0; 1^0 =1; 0^1 = 1 • >> 0x010 = 0x001 <<1 • << 0x001 = 0x010 >>1 DCO

  4. AND Example • 1111 0010 (0xf2) • 1111 1110 (0xfe) • ---------------- (and) & • 1111 0010 (0xf2) • char c = 0xf2; • char d = 0xfe; • Char e = c & d; //e is 0xf2 DCO

  5. OR Example • 1111 0010 (0xf2)1111 1110 (0xfe)--------------(or) |1111 1110 (0xfe) • char c = 0xf2;char d = 0xfe;char e = c | d; //e is 0xfe DCO

  6. One’s complement • 1111 0010 (0xf2)-------------- ~0000 1101 (0x0d) • char c = 0xf2;char e = ~c; //e is 0x0d DCO

  7. EXCLUSIVE OR • 1111 0010 (0xf2)1111 1110 (0xfe)-------------- (^) 0000 1100 (0x0c)char c = 0xf2;char d = 0xfe;char e = c ^ d; //e is 0x0c 0 0 --> 0 1 1 --> 0 0 1 --> 1 1 0 --> 1 DCO

  8. SHIFT >> 1 - (right) by one bit • 1111 0010 (0xf2)>> 1 (shift right by one bit)--------------------- • 0111 10001 (0x79)char c = 0xf2;char e = c >>1; //e is 0x79 DCO

  9. SHIFT >> 2 - by two bits • 1111 0010 (0xf2)>> 2 (shift right by one bit)--------------------- • 0011 1100 (0x3c)char c = 0xf2;char e = c >>2; //e is 0x3c DCO

  10. SHIFT << 1 - (left) by one bit • 1111 0010 (0xf2)<< 1 (shift right by one bit)--------------------- • 1110 0100 (0xe4)char c = 0xf2;char e = c <<1; //e is 0xe4 DCO

  11. SHIFT << 2 - by two bits • 1111 0010 (0xf2)>> 2 (shift right by one bit)--------------------- • 1100 1000 (0xc8)char c = 0xf2;char e = c <<2; //e is 0xc8 DCO

  12. Results or bit operation (example) (1 | 2) == 3 (1 | 3) == 3 (1 & 2) == 0 (1 & 3) == 1 (2 & 3) == 2 (0 ^ 3) == 3 (1 ^ 3) == 2 (2 ^ 3) == 1 (3 ^ 3) == 0 ~0 == -1 (signed) or 255 (unsigned). ~23 == -24 (signed) or 232 (unsigned). DCO

  13. Integer • Formats, Signs, and Precision • Overflow DCO

  14. Data representation • 150 (decimal) is 128(2^7) + 16(2^4) + 4(2^2) + 2(2^1). We can rewrite this as: 1*128 + 0*64 + 0*32 + 1*16 + 0*8 + 1*4 + 1*2 + 0*1 or • 1001 0110 (in hex), In 8 bits, for 32 bits, 2^32 DCO

  15. Format • In C, the size of integer types (short, int, long, etc.) is implementation dependent, but on most machines: • chars are 8 bits • ints and longs are 32 bits • shorts are 16 bits DCO

  16. One’s complement & two’s complement • 1001 0010 //original data • 0110 1101 //reverse 1 to 0, 0 to 1 • One’s complement • 0110 1101 • + • 0000 0001 (add one to one’s complement) • 0110 1110 • Two’s complement DCO

  17. Application of twos’ complement • 1100 0011 – 0011 0001 • -0011 0001 can be converted into two’s complement • The operation becomes addition instead of subtraction • Two’s complement –0011 0001 is 1100 1111 • 1100 0011 – 0011 0001 is • 1100 0011 + 1100 1111 =0001 0010 • Convert “-” to “+” DCO

  18. Signed integer of 100 • Negative sign is represented by 1 (most significant bit) • 100 (decimal) 0x0064 (hex) • 0000 0000 0110 0100 • positive • -100 (decimal) 0xff9c (hex) • 1111 1111 1001 1100 • negative DCO

  19. Example of – 101 (decimal) 101 (decimal ) is 0x0065 (hex) 0000 0000 0110 0101 ( 32 bits integer) -101 is two’s complement 0xff9b Convert 0 to 1, 1 to 0 and then add 1 0000 0000 0110 0101 (101 in decimal) 1111 1111 1001 1010 (convert 1 to 0 and 0 to 1) 1111 1111 1001 1011 (add 1, result) DCO

  20. Left & right Shift • 101 (dec) is 0x0065 (hex) • Shift right by one bit >>1 • 0000 0000 0110 0101 (101 dec) • >> 1 (shift left) • 0000 0000 0011 0010 (50 dec), not 50.5 DCO

  21. Overflow • When integers are too big to fit into a word, overflow occurs. • 16-bit unsigned integer, the largest is 32767 • If you add 32767 + 1 (dec), it produces 0 1111 1111 1111 1111 (binary) + 0000 0000 0000 0001 1 0000 0000 0000 0000 (overflow) DCO

  22. Floating • Fixed-Point Representations – 32.45 • Floating-Point Representations such as 32.45, 3.245 x 10, 0.3245 x 100 • Normalization and Hidden Bits • IEEE Floating Point • Details DCO

  23. Fixed-Point Representations • Such as 123.45 • 1234.78 • The decimal point is fixed DCO

  24. Floating point • A floating-point number is really two numbers packed into one string of bits. • One of the numbers is simply a fixed-point binary number, which is called the mantissa. • The other number acts to shift the binary point left or right to keep the mantissa in a useful range. • This number is called the exponent. DCO

  25. Example of Floating • 1.234 • 78.945 • 12.56 • 4.5 E10 • 4.5 x 10^4 DCO

  26. Expression • 1 bit sign bit, 8 bit exponent, and 23 bit Mantissa (total 32 bits) • -1^Sign * 2^(Exponent - 127) * (1 + Mantissa * 2^-23) • Zero, sign bit is 0, Negative, sign bit is 1 • Exponent is unsigned, minus 127. That is if the value is 128, it means 128 – 127 = 1, if the value is 256, it means 256 – 127 = 128, or the value is zero, it means 0 – 127 = -127. DCO

  27. Example DCO

  28. Expression - Mantissa -23 2 • Mantissa is unsigned bit, the expression is 1 + Mantissa * 2^(-23) • If Mantissa is zero, the expression becomes 1 + 0 * 2^(-23) = 1 • If Mantissa is 2^23, the expression becomes 1 + 2^23 * 2 ^(-23) = 1 + 1 = 2 • It ranges from 1 to 2 DCO

  29. Example • 2.5 (floating point) • 0100 0000 0010 0000 0000 0000 0000 0000 • Sign: positive (1) • Exponent : 1000 0000 : 128 (128 – 127 = 1) • Mantissa: 1. 010 0000 0000 0000 0000 0000, 1.25 • Result 1 x 1.25 x 2^1 = 2.5 DCO

  30. Example • Determine the values of • 1011 1101 0100 0000 0000 0000 0000 0000 • Sign = 1, negative • Exponent = 122 so exponent = -5 (122 – 127) • Mantissa: 100 0000 0000 0000 0000 0000 = 1.1 • So result –1 x 1.1 x 2^(-5) 2 = -0.046875 10 (decimal) DCO

  31. Two representation of Zero • When the sign bit is zero, positive, exponent is zero and Mantissa is zero • When the sign bit is 1, negative, exponent is zero and Mantissa is zero • In short, there are two formats of ZERO DCO

  32. IEEE Double Precision – 64 bits • 64 bits • with • 11 exponent bits • 52 mantissa bits • Plus one bit sign bit • C++ uses 32 bits (4 bytes) instead of 64 bits DCO

  33. Summary • Bit operation, &, |, ~, >> or << • Representation of data, int, short, long • Floating point – sign, magnitude, mantissa for example, -3.4 x10^4 • - (negative), 3.5 (mantissa), 4 magnitude • 0x00341256 can be an integer, floating point, or a statement. That is why we need to define int i; Char a; DCO

More Related