bit-manipulation

What is the fastest way to flip the sign of a double (or float) in C? I thought, that accessing the sign bit directly would be the fastest way and found the following: double a = 5.0; *(__int64*)&a |= 0x8000000000000000; // a = -5.0 float b = 3.0; *(int*)&b |= 0x80000000; // b = -3.0 However, the above does not work for negative numbers: double a = -5.0; *(__int64*)&a |= 0x8000000000000000; // a = -5.0 Any decent compiler will implement this bit manipulation if you just prepend a negation operator, i.e. -a . Anyway, you're OR-ing the bit. You should XOR it. This is what the compilers I tested

Possible Duplicate: Why do we usually use || not | , what is the difference? Can I use single ampersand like & instead of a bitwise operator like && ? What kind of differences may arise and is there a specific example to illustrate this issue clearly? The single & will check both conditions always. The double && will stop after the first condition if it evaluates to false. Using two is a way of "short circuiting" the condition check if you truly only need 1 condition of 2 to be true or false. An example could be: if (myString != null && myString.equals("testing")) If myString is null , the

In the yester Code Jam Qualification round http://code.google.com/codejam/contest/dashboard?c=433101#s=a&a=0 , there was a problem called Snapper Chain. From the contest analysis I came to know the problem requires bit twiddling stuff like extracting the rightmost N bits of an integer and checking if they all are 1. I saw a contestant's(Eireksten) code which performed the said operation like below: (((K&(1<<N)-1))==(1<<N)-1) I couldn't understand how this works. What is the use of -1 there in the comparison?. If somebody can explain this, it would be very much useful for us rookies. Also, Any

I don't quite understand this whole bitmask concept. Let's say I have a mask: var bitMask = 8 | 524288; I undestand that this is how I would combine 8 and 524288 , and get 524296 . BUT, how do I go the other way? How do I check my bitmask, to see if it contains 8 and/or 524288 ? To make it a bit more complex, let's say the bitmask I have is 18358536 and I need to check if 8 and 524288 are in that bitmask. How on earth would I do that? well if (8 & bitmask == 8 ) { } will check if the bitmask contains 8. more complex int mask = 8 | 12345; if (mask & bitmask == mask) { //true if, and only if,

The 2's complement of a number which is represented by N bits is 2^N-number. For example: if number is 7 (0111) and i'm representing it using 4 bits then, 2's complement of it would be (2^N-number) i.e. (2^4 -7)=9(1001) 7==> 0111 1's compliment of 7==> 1000 1000 + 1 ------------- 1001 =====> (9) While calculating 2's complement of a number, we do following steps: 1. do one's complement of the number 2. Add one to the result of step 1. I understand that we need to do one's complement of the number because we are doing a negation operation. But why do we add the 1? This might be a silly question