Unfortunately, even x86-64 implementations can differ – from Intel’s instruction set reference,BSF and BSR, with a source operand value of (0), leaves the destination undefined, and sets the ZF (zero flag). So the behaviour may not be consistent between micro-architectures or, say, AMD and Intel. (I believe AMD leaves the destination unmodified.) The newer LZCNT … Read more
int t = (data[c] – 128) >> 31; The trick here is that if data[c] >= 128, then data[c] – 128 is nonnegative, otherwise it is negative. The highest bit in an int, the sign bit, is 1 if and only if that number is negative. >> is a shift that extends the sign bit, … Read more
The so-called usual arithmetic conversions apply to many binary operators, but not all of them. For example they do not apply to the bit shift operators, &&, ||, comma operator, and assignment operators. This is the rule for the bit shift operators: 6.5.7 … 3 Semantics … The integer promotions are performed on each of … Read more
Try this one: (n >> 1) ^ (-(n & 1)) Edit: I’m posting some sample code for verification: #include <stdio.h> int main() { unsigned int n; int r; for(n = 0; n < 10; n++) { r = (n >> 1) ^ (-(n & 1)); printf(“%u => %d\n”, n, r); } return 0; } I … Read more
The number 0177 is an octal number representing the binary pattern below: 0000000001111111 When you AND it using the bitwise operation &, the result keeps the bits of the original only in the bits that are set to 1 in the “mask”; all other bits become zero. This is because “AND” follows this rule: X … Read more
http://docs.oracle.com/javase/specs/jls/se7/html/jls-15.html#jls-15.22.1 15.19 Shift Operators If the promoted type of the left-hand operand is int, only the five lowest-order bits of the right-hand operand are used as the shift distance. It is as if the right-hand operand were subjected to a bitwise logical AND operator & (§15.22.1) with the mask value 0x1f. The shift distance actually … Read more
You can use a strategy from this collection of Bit Twiddling Hacks: function bitCount (n) { n = n – ((n >> 1) & 0x55555555) n = (n & 0x33333333) + ((n >> 2) & 0x33333333) return ((n + (n >> 4) & 0xF0F0F0F) * 0x1010101) >> 24 } console.log(bitCount(0xFF)) //=> 8 Note that the … Read more
In C, to get an unsigned shift, you just do a shift on an unsigned type. unsigned int result = (unsigned int)valueToBeShifted >> shiftAmount; Note that there is no guarantee that >> on a signed type gives you a signed shift in C — this is implementation defined behavior. Most common implementations produce a signed … Read more
The C equivalent of the Go expression x &^ y is just x & ~y. That is literally “x AND (bitwise NOT of y)”. In the arithmetic operators section of the spec describes &^ as a “bit clear” operation, which gives an idea of what you’d want to use it for. As two separate operations, … Read more
In short, (high + low) >>> 1 is a trick that uses the unused sign-bit to perform a correct average of non-negative numbers. Under the assumption that high and low are both non-negative, we know for sure that the upper-most bit (the sign-bit) is zero. So both high and low are in fact 31-bit integers. … Read more