bit-shift

This question already has an answer here: Implementing Logical Right Shift in C 8 answers Right now I am reading the book Computer Systems : Programmer Perspective. One problem in the book says to perform a logical right shift on a signed integer, I can't figure out how to start on this. The following is the actual question from the book: Fill in code for the following C functions. Function srl performs a logical right shift using an arithmetic right shift (given by value xsra ), followed by other operations not including right shifts or division. Function sra performs an arithmetic right

I'm trying to calculate the time complexity of a simple algorithm in big O notation, but one part of it is seriously boggling my mind. Here is a simplified version of the algorithm: int a=n while(a>0) { //for loop with time complexity n^3 a = a/8 } In this instance, it's integer division, so the while loop will terminate after a's value drops below 8. I'm not sure how to express this in terms of n. I'd also like to know how to tackle future calculations like this, where the number of loops isn't too easy to define. I find it easier to do it the other way around in cases like this. What is the

I have a test program like this: int main() { unsigned n = 32; printf("ans << 32 = 0x%X\n", (~0x0U) << 32); printf("ans >> 32 = 0x%X\n", (~0x0U) >> 32); printf("ans << n(32) = 0x%X\n", (~0x0U) << n); printf("ans >> n(32) = 0x%X\n", (~0x0U) >> n); return 0; } It produces the following output: ans << 32 = 0x0 ... (1) ans >> 32 = 0x0 ... (2) ans << n(32) = 0xFFFFFFFF ... (3) ans >> n(32) = 0xFFFFFFFF ... (4) I was expecting (1) and (3) to be the same, as well as (2) and (4) to be the same. Using gcc version: gcc.real (Ubuntu 4.4.1-4ubuntu9) 4.4.1 What is happening? Shifting by the size of the

I have 3 unsigned bytes that are coming over the wire separately. [byte1, byte2, byte3] I need to convert these to a signed 32-bit value but I am not quite sure how to handle the sign of the negative values. I thought of copying the bytes to the upper 3 bytes in the int32 and then shifting everything to the right but I read this may have unexpected behavior. Is there an easier way to handle this? The representation is using two's complement. You could use: uint32_t sign_extend_24_32(uint32_t x) { const int bits = 24; uint32_t m = 1u << (bits - 1); return (x ^ m) - m; } This works because: if

I think understand what they fundamentally do - operate on bits (flip, shift, invert, etc...). My issue is that I don't know when I'd ever need to use them, and I don't think I fully understand bits. I know that there are 8 bits in a byte and I know that bits are either a 0 or 1 . Now here is where I start to get confused... I believe data types define combinations of bits differently. So if I declare an int , 32 bits are set aside for numbers, if I declare a char, 8 bits are set aside and the bits for that data type define a letter. Running with that idea, I did the following basic operation

I have problem with shift operator in Java.I have used following code and not unable to understand how this program generates this output.So please guide me how this program generates this output. public class Operator { public static void main(String[] args) { // TODO Auto-generated method stub int s = 8; s = s >>-63; System.out.println("value of i=" + s); } } Output: value of i=4 From the JLS, section 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

I have been reading all around about be aware >> as ending of nested template and >> as shift operator... Now I have tried it in my MSVS2010 and no problem occured. std::map<int, std::pair<int, int>> m; This code works exactly what I want (map of pairs) but I supposed to get some error about >> Compiler is smarter these days? MSVC++2010 supports C++0x feature Right Angle Brackets Be careful because previously good C++03 code may break with compilers supporting this feature. MyArray< MyArray<int, 16 >> 2>, 5 > arrayInst; This would be the fix: MyArray< MyArray<int, (16 >> 2)>, 5 > arrayInst;