signed

I want to do 32-bit signed integer multiplication without using a 64-bit data type. My inputs are in Q1.31 (both) format. input1 = A32 (Ah Al) - higher, lower half's of A32 input2 = B32 (Bh Bl) - higher, lower half's of B32 Result should be in Q1.31 format, leave the overflow case. I need C code. Please provide the explanation with formats also. Signed Q1.31 format is a fully fractional format capable of representing operands between -1 and almost +1. The scale factor is 2 31 . This means that when each Q1.31 operand is stored in a 32-bit signed integer, we can generate the Q1.31 product by

For representing a length or count variable, is it better to use signed or unsigned integers? It seems to me that C++ STL tends to prefer unsigned ( std::size_t , like in std::vector::size() , instead C# BCL tends to prefer signed integers (like in ICollection.Count . Considering that a length or a count are non-negative integers, my intuition would choose unsigned ; but I fail to understand why the .NET designers chose signed integers. What is the best approach? What are the pros and cons of each one? C++ uses unsigned values because they need the full range. On a 32-bit system, the language

This question already has an answer here: sizeof() operator in if-statement 5 answers #include <stdio.h> int arr[] = {1,2,3,4,5,6,7,8}; #define SIZE (sizeof(arr)/sizeof(int)) int main() { printf("SIZE = %d\n", SIZE); if ((-1) < SIZE) printf("less"); else printf("more"); } The output after compiling with gcc is "more" . Why the if condition fails even when -1 < 8 ? The problem is in your comparison: if ((-1) < SIZE) sizeof typically returns an unsigned long , so SIZE will be unsigned long , whereas -1 is just an int . The rules for promotion in C and related languages mean that -1 will be

This question already has an answer here: (-2147483648> 0) returns true in C++? 4 answers AFAIK this is a standard "idiom" # define INT_MIN (-INT_MAX - 1) # define INT_MAX 2147483647 Question: Why is the definition of INT_MIN not as -2147483648? Because 2147483648 is a long value as it does not fit in an int (in common system with 32-bit int and 64-bit long , on system with 32-bit long it is of type long long ). So -2147483648 is of type long , not int . Remember in C, an unsuffixed decimal integer constant is of the first type int , long or long long where it can be represented. Also in C

In Java, there is no such thing as an unsigned byte. Working with some low level code, occasionally you need to work with bytes that have unsigned values greater than 128, which causes Java to interpret them as a negative number due to the MSB being used for sign. What's a good way to work around this? (Saying don't use Java is not an option) When reading any single value from the array copy it into something like a short or an int and manually convert the negative number into the positive value it should be. byte[] foobar = ..; int value = foobar[10]; if (value < 0) value += 256 // Patch up