Integer Conversion in Floating Point Arithmetic

Question

I currently face the following dilemma:

1.0f * INT32_MAX != INT32_MAX

Evaluating 1.0f * INT32_MAX actually gives me INT32_MIN

I'm not completely surprised by this, I know floating point to integer conversions aren't always exact.

What is the best way to fix this problem?

The code I'm writing is scaling an array of rational numbers: from -1.0f <= x <= 1.0f to INT32_MIN <= x <= INT32_MAX

Here's what the code looks like:

void convert(int32_t * dst, const float * src, size_t count){
    size_t i = 0;
    for (i = 0; i < count; i++){
        dst[i] = src[i] * INT32_MAX;
    }
}

Here's what I ended up with:

void convert(int32_t * dst, const float * src, size_t count){
    size_t i = 0;
    for (i = 0; i < count; i++){
        double tmp = src[i];
        if (src[i] > 0.0f){
            tmp *= INT32_MAX;
        } else {
            tmp *= INT32_MIN;
            tmp *= -1.0;
        }
        dst[i] = tmp;
    }
}

Answer 1

In IEEE754, 2147483647 is not representable in a single precision float. A quick test shows that the result of 1.0f * INT32_MAX is rounded to 2147483648.0f, which can't be represented in an int.

In other words, it is actually the conversion to int that causes the problem, not the float calculation, which happens to be only 1 off!

Anyway, the solution is to use double for the intermediate calculation. 2147483647.0 is OK as a double precision number.