bit-manipulation

I would like to know if the following is possible in any of the SIMD families of instructions. I have a qword input with 63 significant bits (never negative). Each sequential 7 bits starting from the LSB is shuffle-aligned to a byte, with a left-padding of 1 (except for the most significant non-zero byte). To illustrate, I'll use letters for clarity's sake. The result is only the significant bytes, thus 0 - 9 in size, which is converted to a byte array. In: 0|kjihgfe|dcbaZYX|WVUTSRQ|PONMLKJ|IHGFEDC|BAzyxwv|utsrqpo|nmlkjih|gfedcba Out: 0kjihgfe|1dcbaZYX|1WVUTSRQ|1PONMLKJ|1IHGFEDC|1BAzyxwv

I am trying to figure out the algorithm to this but all I get with google is doing it with casting. I need to know the details. So if we have a float x and want to return its binary representation what do we need to do? I know we need to return the float if its NaN or a infinity but otherwise what are the steps? EDIT The function takes in an unsigned int, to be used as if it was a float, and then return the integer the number represents. I cannot use casting, just conditionals and bit-wise operators. Alternatively, use a union: typedef union { float f_; int i_; } FloatBits; FloatBits fb; fb.f_

I've got a long variable and I need to reverse its byte order. For example: B1, B2, ... , B8 I should return a long that consists of B8, B7, ..., B1 . How can I do it by using bitwise operations? Serdalis you can use Long.reverseBytes(long) Or for more methods which include bitwise operations, you can refer to this stack overflow question Heres another method you may like, I'd still recommend the above but it's better than bitwise where you can easily make mistakes. Bytebuffer byte[] bytes = ByteBuffer.allocate(8).putLong(someLong).array(); for (int left = 0, right = bytes.length - 1; left <

I would like to know some examples of application of circular shifts. For example, a right shift on an unsigned integer would result in a division by two. Conversely, a left shift would result in a multiplication by 2. Are there any famous/interesting properties of a circular shift on binary numbers. Note: The example about the right/left shift is to illustrate an application of that particular operator. I am asking for similar examples for the circular shift operator/function. Convert a 16-bit word between big-endian and little-endian representation: right or left circular shift by 8.

I'm not used to binary files, and I'm trying to get the hang of it. I managed to store some integers and unsigned char, and read them without too much pain. Now, when I'm trying to save some booleans, I see that each of my bool takes exactly 1 octet in my file, which seems logical since a lone bool is stored in a char-sized data (correct me if I'm wrong!). But since I'm going to have 3 or 4 bools to serialize, I figure it is a waste to store them like this : 00000001 00000001 00000000, for instance, when I could have 00000110. I guess to obtain this I should use bitwise operation, but I'm not

I use bitwise to turn bits on and off this way: unsigned char myChar = ...some value myChar |= 0x01 << N // turn on the N-th bit myChar &= ~(0x01 << N) //turn off the N-th bit Now, suppose the value of N is know but the set/unset operation depends on the value of a bit of another unsigned char. Since now, I'm doing this way: if ((otherChar & (0x01 << M)) != 0) { //M-th bit of otherChar is 1 myChar |= 0x01 << N; }else { myChar &= ~(0x01 << N); } This should be a sort of "moving bit" operation from an unsigned char to another. My question: is there any way of doing this without using the