bit-manipulation

The following the magical formula which gives the number of bits set in a number (Hamming weight). /*Code to Calculate count of set bits in a number*/ int c; int v = 7; v = v - ((v >> 1) & 0x55555555); // reuse input as temporary v = (v & 0x33333333) + ((v >> 2) & 0x33333333); // temp c = ((v + (v >> 4) & 0xF0F0F0F) * 0x1010101) >> 24; // count printf(" Number of Bits is %d",c); /*-----------------------------------*/ from: http://graphics.stanford.edu/~seander/bithacks.html Can anyone please explain me the rationale behind this? It's really quite clever code, and is obviously a lot more

I understand the >>> fixes the overflow: when adding two big positive longs you may endup with a negative number. Can someone explain how this bitwise shift magically fixes the overflow problem? And how it is different than >> ? My suspicious: I think it has to do with the fact that Java uses two-compliments so the overflow is the right number if we had the extra space but because we don't it becomes negative. So when you shift and paddle with zero it magically gets fixed due to the two-compliments. But I can be wrong and someone with a bitwise brain has to confirm. :) In short, (high + low) >

According to wiki shifts can be used to calculate powers of 2: A left arithmetic shift by n is equivalent to multiplying by 2^n (provided the value does not overflow), while a right arithmetic shift by n of a two's complement value is equivalent to dividing by 2^n and rounding toward negative infinity. I was always wondering if any other bitwise operators ( ~ , | , & , ^ ) make any mathematical sense when applied to base-10? I understand how they work, but do results of such operations can be used to calculate anything useful in decimal world? "yep base-10 is what I mean" In that case, yes,

I have four flags Current = 0x1 Past = 0x2 Future = 0x4 All = 0x7 Say I receive the two flags Past and Future ( setFlags(PAST | FUTURE) ). How can I tell if Past is in it? Likewise how can I tell that Current is not in it? That way I don't have to test for every possible combination. If you want all bits in the test mask to match: if((value & mask) == mask) {...} If you want any single bit in the test mask to match: if((value & mask) != 0) {...} The difference is most apparent when you are testing a value for multiple things. To test for exclusion: if ((value & mask) == 0) { } First of all -

This question already has an answer here: How do you set, clear, and toggle a single bit? 27 answers We have an integer number int x = 50; in binary, it's 00110010 How can I change the fourth (4th) bit programatically? You can set the fourth bit of a number by OR-ing it with a value that is zero everywhere except in the fourth bit. This could be done as x |= (1u << 3); Similarly, you can clear the fourth bit by AND-ing it with a value that is one everywhere except in the fourth bit. For example: x &= ~(1u << 3); Finally, you can toggle the fourth bit by XOR-ing it with a value that is zero

In the following code: short = ((byte2 << 8) | (byte1 & 0xFF)) What is the purpose of &0xFF ? Because other somestimes I see it written as: short = ((byte2 << 8) | byte1) And that seems to work fine too? John Colanduoni Anding an integer with 0xFF leaves only the least significant byte. For example, to get the first byte in a short s , you can write s & 0xFF . This is typically referred to as "masking". If byte1 is either a single byte type (like uint8_t ) or is already less than 256 (and as a result is all zeroes except for the least significant byte) there is no need to mask out the higher