1. CSC 270 – Survey of Programming Languages C Lecture 5 – Bitwise Operations and Operations Miscellany

2. Logical vs. Bitwise Operations Logical operations assume that the entire variable represents either true or false. – Combining two integer values using a logical operator produces one result, with the variable representing true or false. Bitwise operations assume that each bit in the variable’s value represents a separate true or false. – Combining two integer values using a bitwise operators produces 8 (or 16 or 32 or 64) separate bits each representing a true or a false.

3. Logical Values in C Although the 1999 standard for C includes booleans, it does not exist in older versions. Integers are usually used for boolean values, with nonzero values being accepted as true and zero values being accepted as false. Boolean operations will produce a 1 for true and a 0 for false.

4. && - Logical AND The logical AND operator is && and produces a 1 if both operands are nonzero; otherwise, it produces a 0. 111 001 010 000 x &&yyx

5. && – An Example #include intmain(void) { unsignedu, v, w, x = 0x10, //(hex 16) y = 0x110, //(hex 272: 256 + 16) z = 0x0; //(hex 0) u = x && y; v = x && z; w = y && z; printf("u = %x\tv = %x\tw = %x\n", u, v, z); return(0); } Output u = 1 v = 0 w = 0

6. || - Logical OR The logical OR operator is || and produces a 1 if either operands is nonzero; otherwise, it produces a 0.

7. Logical || – An Example #include intmain(void) { unsignedu, v, w, x = 0x10, y = 0x110, z = 0x0; u = x || y; v = x || z; w = y || z; printf("u = %x\tv = %x\tw = %x\n", u, v, z); return(0); } Output u = 1 v = 1 w = 1

8. Logical NOT The logical NOT operator ! Inverts the value; nonzero becomes 0 and 0 becomes 1.

9. Logical NOT – An Example #include intmain(void) { unsigned x = 0x110, y; y = !x; // because x has something, it becomes 0 printf("x = ox%x\ty = ox%x\n", x, y); x = 0x0; y = !x; // because x is 0, it becomes 1 printf("x = ox%x\ty = ox%x\n", x, y); return(0); } Output x = ox110 y = ox0 x = ox0 y = ox1

10. Bitwise Operations Bitwise operations treat the operands as 8-bit (or 16- or 32-bit) operands. Performing a bit- wise AND operation on two 8-bit integers means that 8 AND s are performed on corresponding bits. Example: 00111011 00001111 00001011

11. Bitwise AND & A bitwise AND operation is actually 8 (or 16 or 32) AND operations. An example of AND ing: 0 0 1 1 1 0 1 1 0 0 0 0 1 1 1 1 0 0 0 0 1 0 1 1 The AND instruction can be used to clear selected bits in an operand while preserving the remaining bits. This is called masking. clearedunchanged

12. Bitwise AND & – An Example http://www.rapidtables.com/convert/number/how-hex-to- binary.htm unsignedu, v, w, x = 0xab87, //(1010 1011 1000 0111) y = 0x4633, //(0100 0110 0011 0011) z = 0x1111; //(0001 0001 0001 0001) u = x & y; v = x & z; w = y & z; printf("u = ox%x\tv = ox%x\tw = ox%x\n", u, v, w); Output u = ox203 v = ox101 w = ox11 ox203 binary 0010 0000 0011 (was x & y) ox101 binary 0001 0000 0001 (was x & z) ox11 binary 0000 0001 0001 (was y & z)

13. Bitwise OR | A bitwise OR operation is actually 8 (or 16 or 32) OR operations. An example of OR ing: 0 0 1 1 1 0 1 1 0 0 0 0 1 1 1 1 0 0 1 1 1 1 1 1 The OR instruction can be used to set selected bits in an operand while preserving the remaining bits. unchanged set

14. Bitwise OR | – An Example unsignedu, v, w, x = 0xab87, //(1010 1011 1000 0111) y = 0x4633, //(0100 0110 0011 0011) z = 0x1111; //(0001 0001 0001 0001) u = x | y; v = x | z; w = y | z; printf("u = ox%x\tv = ox%x\tw = %oxx\n“, u, v, w); Output u = oxefb7 v = oxbb97 w = ox5733 oxefb7 binary 1110 1111 1011 0111(was x & y) oxbb97 binary 1011 1011 1011 0111(was x & z) ox5733 binary 0101 0111 0011 0011(was y & z)

15. Bitwise NOT ~ (One’s Complement) The bitwise NOT (better known as the one’s complement) inverts each bit in the operand. Example unsigned x, y = 0xab87; x = ~y; printf("x = %x\ty = %x\n", x, y); Output x = ffff5478 y = ab87 Add 1 to this to make a two’s complement – negative number representation

16. Bitwise XOR ^ A bitwise XOR operation is actually 8 (or 16 or 32) AND operations. An example of XOR ing: 00111011 00111111 00000100 The XOR instruction can be used to reverse selected bits in an operand while preserving the remaining bits. unchangedinverted

17. Bitwise XOR – An Example unsignedu, v, w, x = 0xab87, y = 0x4633, z = 0x1111; u = x ^ y; v = x ^ z; w = y ^ z; printf("u = %x\tv = %x\tw = %x\n", u, v, w); Output u = edb4 v = ba96 w = 5722

18. Bit Shifting To make your mask >> Right shifting << Left Shifting x = 0x ff ; // 1111 1111 y = x << 8; /* y is 0x ff00 */ // 1111 1111 0000 0000 Results may vary depending on the computer – int can be different sizes on different computers. x & ~077 will turn off lowest six bits.

19. getbits() /* * getbits() - Get n bits from position p */ unsigned getbits(unsigned x, int p, int n) { return ((x >> (p + 1 - n)) & ~(~0 << n)); } /** if p is 4 and n is 3 – 3 bits from pos 4 x is oxfb (1111 1011) ((oxfb >> (4 + 1 – 3)) & ~(~0 << 3)); ((1111 1011 >> 2 ) & ~(1111 1111 << 3)) ((0011 1110) & ~(1111 1000 )) ((0011 1110) & (0000 0111)) 0000 0110

20. Assignment Operators An assignment operator is just another operator in C. We can rewrite i = i + 2; as i += 2; or i = i + x * y; as i += x * y; Similarly, there are -=, *=, /=, etc.

21. Assignment Operators Caution! i *= 2 + y; is rewritten as i = i * (2+y); NOT i = (i *2) + y;

22. bitcount() /* * bitcount() - Count 1s in x */ int bitcount(unsigned x) { int b; for (b = 0; x != 0; x >>= 1) if (x & 01) b++; return(b); }

23. Conditional Expressions Why write if (a > b) z = a; else a = b; when you can write z = (a > b)? a : b;

24. Conditional Expressions The general form is expression1? expression2: expression3; when expression1 is nonzero, expression2 is evaluated. Otherwise expression3 is evaluated. The usual rules of conversion are in effect. inti, j, a, b; floatx; … i = (a > b)? j: x;

25. Conditional Expressions If this useful? YES!! z = (a > b)? a : b;/* z = max (a, b); */ x = (x > 0)? x : -x;/* x = abs(x) */ /* Print 5 values to a line */ for (i = 0; i < MAXSIZE; i++) printf("%d%c", x[i], i % 5 == 4? '\n':'\t');

26. Operator Precedence OperatorAssociativity () [] ->. left to right ! ~ ++ -- - unary (type) * (ptr) & (address) sizeof right to left * / % left to right + - left to right > left to right >= left to right == != left to right & (bitwise AND) left to right ^ (bitwise XOR) left to right | (bitwise OR) left to right

27. Bitwise Summary Bitwise operators act on bits inside the number 1 hex digit = 4 binary digits Mask – the number set for comparison & - used to clear bits – 1 = both true; – 0 in the mask clears and 1 preserves original | - used to set bits – 1= either true; – 1 in the mask sets to 1 and 0 preserves original ^ - used to reverse bits – 1 = only one true; – 1 in the mask reverses bits and 0 preserves

28. Bitwise Summary ~ one’s complement – reverses every bit Set your mask using shifting  << a number : left shift by the number and zero fill  >> a number : right shift by the number and zero fill  Extra gift – ternary operator – embedded if/else:  (a > b)? j: x; If a is greater than b then replace expression with j, otherwise replace with x.