bit-manipulation

Background For a long time, gcc has been providing a number of builtin bit-twiddling functions, in particular the number of trailing and leading 0-bits (also for long unsigned and long long unsigned , which have suffixes l and ll ): — Built-in Function: int __builtin_clz (unsigned int x) Returns the number of leading 0-bits in x , starting at the most significant bit position. If x is 0, the result is undefined. — Built-in Function: int __builtin_ctz (unsigned int x) Returns the number of trailing 0-bits in x , starting at the least significant bit position. If x is 0, the result is undefined.

I came across this excerpt today: On most older microprocessors, bitwise operations are slightly faster than addition and subtraction operations and usually significantly faster than multiplication and division operations. On modern architectures, this is not the case: bitwise operations are generally the same speed as addition (though still faster than multiplication). I'm curious about why bitwise operations were slightly faster than addition/subtraction operations on older microprocessors. All I can think of that would cause the latency is that the circuits to implement addition/subtraction

I am pasting the code to find the sum of two numbers with bitwise operator. Please suggest if it can be optimized. Thanks... public static int getSum(int p, int q) { int carry=0, result =0; for(int i=0; i<32; i++) { int n1 = (p & (1<<(i)))>>(i); //find the nth bit of p int n2 = (q & (1<<(i)))>>(i); //find the nth bit of q int s = n1 ^ n2 ^ carry; //sum of bits carry = (carry==0) ? (n1&n2): (n1 | n2); //calculate the carry for next step result = result | (s<<(i)); //calculate resultant bit } return result; } Think in entire bits: public static int getSum(int p, int q) { int result = p ^ q; // +

I have a big lump of binary data in a char[] array which I need to interpret as an array of packed 6-bit values. I could sit down and write some code to do this but I'm thinking there has to be a good extant class or function somebody has written already. What I need is something like: int get_bits(char* data, unsigned bitOffset, unsigned numBits); so I could get the 7th 6-bit character in the data by calling: const unsigned BITSIZE = 6; char ch = static_cast<char>(get_bits(data, 7 * BITSIZE, BITSIZE)); This may not work for sizes greater than 8, depending on endian system. It's basically what

For those who like a good WPF binding challenge: I have a nearly functional example of two-way binding a checkbox to an individual bit of a flags enumeration (thanks Ian Oakes, original MSDN post ). The problem though is that the binding behaves as if it is one way (UI to DataContext, not vice versa). So effectively the check box does not initialize, but if it is toggled the data source is correctly updated. Attached is the class defining some attached dependency properties to enable the bit-based binding. What I've noticed is that ValueChanged is never called, even when I force the

This question directly follows after reading through Bits counting algorithm (Brian Kernighan) in an integer time complexity . The Java code in question is int count_set_bits(int n) { int count = 0; while(n != 0) { n &= (n-1); count++; } } I want to understand what n &= (n-1) is achieving here ? I have seen a similar kind of construct in another nifty algorithm for detecting whether a number is a power of 2 like: if(n & (n-1) == 0) { System.out.println("The number is a power of 2"); } Stepping through the code in a debugger helped me. If you start with n = 1010101 & n-1=1010100 => 1010100 n =