bit-manipulation

We are writing an emulator where we need sign propagating right shift. The emulated system uses 2's complement numbers. I read that the >> operator on signed integers in C is implementation defined. So I cannot rely on the fact it will result in the correct bit pattern in all platforms. This means I'll need to use bit manipulation to reproduce the arithmetic right shift, and I would want to avoid unnecessary branching if possible. EDIT: In response to a comment: "The missing bit is that OP needs to define what result is "correct" when the sign bit is set in x with x >> y" I basically want to

The Haswell architectures comes up with several new instructions. One of them is PEXT ( parallel bits extract ) whose functionality is explained by this image (source here ): It takes a value r2 and a mask r3 and puts the extracted bits of r2 into r1 . My question is the following: what would be the equivalent code of an optimized templated function in pure standard C++11, that would be likely to be optimized to this instruction by compilers in the future. Here is some code from Matthew Fioravante's stdcxx-bitops GitHub repo that was floated to the std-proposals mailinglist as a preliminary

How to set to 1 efficiently with AVX2 first N bits last N bits of __m256i , setting the rest to 0 ? These are 2 separate operations for tail and head of a bit range, when the range may start and end in the middle of __m256i value. The part of the range occupying full __m256i values is processed with all- 0 or all- 1 masks. The AVX2 shift instructions vpsllvd and vpsrlvd have the nice property that shift counts greater than or equal to 32 lead to zero integers within the ymm register. In other words: the shift counts are not masked, in contrast to the shift counts for the x86 scalar shift

In C, I can write an if-statement if (firstInt & 1) but when I try and do the same in Java, the compiler tells me "incompatible types" and says I need a boolean instead of an int . Is there any way to write that C code in Java? Any of the following should work for you: if ((firstInt & 1) != 0) if ((firstInt & 1) > 0) if ((firstInt & 1) == 1) In C an integer expression can be used implicitly as a boolean expression (although I would argue that it is a bad idea), where zero is false and any non-zero value is true. In Java that is not allowed so you have to make the expression explicitly boolean

In Java: (0xFFFFFFFF << 1) = 0xFFFFFFFE = 0b1111111111111110 : : : (0xFFFFFFFF << 30) = 0xE0000000 = 0b1110000000000000 (0xFFFFFFFF << 30) = 0xC0000000 = 0b1100000000000000 (0xFFFFFFFF << 31) = 0x80000000 = 0b1000000000000000 However: (0xFFFFFFFF << 32) = 0xFFFFFFFF = 0b1111111111111111 Logically this makes no sense, but what I believe to be happening is Java performing an operation similar to: a << (b % Integer.SIZE) [edit, apparently:] a << (b & 0x1F) This applies to >> and >>> , too. Obviously shifting by >= 32 (in the case of an Integer) removes all data from the data-type, but there are

I'm trying to optimize some bit packing and unpacking routines. In order to do the packing I need to calculate the number of bits needed to store integer values. Here is the current code. if (n == -1) return 32; if (n == 0) return 1; int r = 0; while (n) { ++r; n >>= 1; } return r; You're looking to determine the integer log base 2 of a number (the l=highest bit set). Sean Anderson's "Bit Twiddling Hacks" page has several methods ranging from the obvious counting bits in a loop to versions that use table lookup. Note that most of the methods demonstrated will need to be modified a bit to work

I have some performance-heavy code that performs bit manipulations. It can be reduced to the following well-defined problem: Given a 13-bit bitmap, construct a 26-bit bitmap that contains the original bits spaced at even positions . To illustrate: 0000000000000000000abcdefghijklm (input, 32 bits) 0000000a0b0c0d0e0f0g0h0i0j0k0l0m (output, 32 bits) I currently have it implemented in the following way in C: if (input & (1 << 12)) output |= 1 << 24; if (input & (1 << 11)) output |= 1 << 22; if (input & (1 << 10)) output |= 1 << 20; ... My compiler (MS Visual Studio) turned this into the following: