Conversion between 64-bit and 32-bit fixed-point numbers

Question

How to convert data from Q33.31 format to Q2.30 format? I know that we need to use shift operators if both input and output are of same bit size. But how to calculate if they are of different size?

Answer 1

The key here is just shift the radix point to the correct place. Take a simple example from Q9.7 format to Q2.6 like this

in  9 8 7 6 5 4 3 2 1.1 2 3 4 5 6 7
out                 2 1.1 2 3 4 5 6

As you can see the output's radix point's positions is 1 to the right of the input, so we need to right shift to put it in the right position. You can also think like this: there's 1 less bit in the output's fractional part so we'll right shift 1 bit to truncate it from 7 bits to 6 bits. The 7 high bits of the integer part will be automatically truncated in C when you do an assignment to the narrower type. That's equivalent to

uint8_t out = in >> 1;

Similarly to convert from Q33.31 to Q2.30 you'll do the same: q2_30 = q33_31 >> 1

However now to get a more correct result you'll need to do a rounding step. There are many round methods but the simplest way is just round to the nearest by checking if the value is above or lower than 0.5. Like in decimal where we check the first truncated digit to see if it's >= 5 or not, in binary we check the last bit that was shifted out and add it back to the result like this

uint32_t q2_30 = (q33_31 >> 1) + (q33_31 & 1)

Edit

There's absolutely no need to do truncate to do that when you just want the sum of two Q1.31 bit numbers. Just convert them to Q2.30 using the above method, add then round later

uint32_t A2_30 = A1_31 >> 1; // types must be unsigned so that the shifts are logical
uint32_t B2_30 = B1_31 >> 1; // instead of arithmetic

// if only one of the values is 1 then their sum is 0.5 ULP which will be rounded to 1
uint32_t carry = (A1_31 & 1) | (B1_31 & 1); // if both of them are 1 then sum = 1 ULP

Q2_30 sum = A2_30 + B2_30 + carry;

Answer 2

In a comment on @goodvibration's answer you state that you're adding two Q1.31 numbers. Given that, you know that your result is representable as Q2.31, so to convert your Q2.31 number to Q2.30 you just need to shift the result right by one bit:

uint32_t convert_q231_q230(uint64_t x)
  {
  return (uint32_t) (x >> 1);
  }

Answer 3

How about this:

uint32_t convert(uint64_t x)
{
    uint32_t hi = (uint32_t)(x >> 32);
    uint32_t lo = (uint32_t)(x);
    if (hi >= (1 << 2) || lo >= (1 << 30))
        // handle input-too-large-or-too-accurate error and exit
    return (hi << 30) | lo;
}

Alternatively to handling erroneous input in the if statement (if you don't care about possible information-loss), you can simply return (hi << 30) | ((lo << 2) >> 2);.