I have big interest in HPDC and this section of my blog is all about HPDC. Most of my examples are with C unless stated otherwise. I hope you learn from this section and don’t hesitate to ask questions!

1. char
2. short
3. int
4. long

Article outline
I’ll talk about each of the following operations and give some examples on how to use each.

1. Bitwise NOT (~)
2. Bitwise AND (&)
3. Bitwise OR (|)
4. Bitwise XOR (^)
5. Shift Left (<<)
6. Shift Right(>>)

Bitwise NOT (~)
This is an unary operator. It simply filps all ‘0’s to ‘1’s and ‘1’s to ‘0’s. Here is a simple example:

unsigned byte x = 10;
x = 00001010
~x = 11110101

Bitwise AND (&)
This is a binary operator. Just follow the truth table. Both bits have to be true to get a resulting true bit. Anything else is false. Here is a simple example:

unsigned byte x = (10&8);
10  = 00001010
8   = 00001000
x   = 00001000

Bitwise OR (|)
This is a binary operator. Just follow the truth table. Here, just one of the bits has to be true to get a resulting true. Here is a simple example:

unsigned byte x = (10|8);
10  = 00001010
8   = 00001000
x   = 00001010

Bitwise XOR (^)
This is a binary operator. Just follow the truth table. Basically it flags all bits that are different. Here is a simple example:

unsigned byte x = (10^15);
10  = 00001010
15  = 00001111
x   = 00000101

Shift Left (<<)
Keep in mind that when you do one of the shift operators the size of the data type does not change.
A left shift, moves the bits to the left inserting ‘0’s in the right most bit for every shift. The left most bit is discarded. This is effectively multiplying the number by 2. Note if you use too many shifts you could end up with a negative number. This is possible if the data type is interpreted as 2’s complement. Here is a simple example:

unsigned byte x = 4 << 2;
4   = 00000100
x   = 00010000
x = 16

Shift Right (>>)
A rightshift, moves the bits to the right inserting ‘0’s in the left most bit for every shift. The right most bit is discarded. This is effectively dividing the number by 2. Note if you use too many shifts you could end up with a zero. Here is a simple example:

unsigned byte x = 4 >> 2;
4   = 00000100
x   = 00000001
x = 1

That wraps up the bitwise operators. If there is anything I forgot, let me know and I’ll make the updates. I hope you learned something in this read. Remember these are operation which the processor can execute very fast. For example, if you every need to multiple or divide by 2, it best to use the shift operations. Not only will you code execute faster, but also save you processor some energy!