浮点代码中的错误，还是gcc？

Question

The following code works as expected for me under 64-bits, but fails under 32-bit at -O2 and -O3, the expected output is 1.1, under the bugged systems it prints 1.0. I'm trying to establish if this is a bug in my code (making some bad assumptions about how floats work) or in GCC. If it's in my code, how on earth do I go about fixing it?

#include <math.h>
#include <stdio.h>


int f(double x) {
    return isinf(1.0 / x);
}

int m_isinf(double x) {
    return x != 0 && x * 0.5 == x;
}

int g(double x) {
    return m_isinf(1.0 / x);
}

double values[] = {
    5.5e-309,
    -1.0
};

int main() {
    int i;
    for (i = 0; values[i] != -1.0; i++) {
        printf("%d\n", f(values[i]));
        printf("%d\n", g(values[i]));
    }
    return 0;
}

Answer 1

Expression may be evaluated with more precision than the type. In your 32 bit build, the compiler is probably using the 80 bits long double (which is no more used in 64 bits) to evaluate x != 0 && x * 0.5 == x .

(GCC has know problems with this rules, evaluating with more precisions in context where it can't).

6.3.1.8/2 in C99 (6.2.1.5 in C90 is equivalent):

The values of floating operands and of the results of floating expressions may be represented in greater precision and range than that required by the type; the types are not changed thereby

In a conforming implementation:

int m_isinf(double x) {
    double const half_x = x * 0.5;
    return x != 0 && half_x == x;
}

should work. But gcc bug ( http://gcc.gnu.org/bugzilla/show_bug.cgi?id=323 look at the number of duplicates) often prevent this to work. There are some work around in the bug report.

Answer 2

基本上，在浮点数和双精度数上使用相等比较是意外行为的可靠方法。

Answer 3

You can check the value directly, like so:

#include <math.h>

int isinf(double d) {
  union {
    unsigned long long l;
    double d;
  } u;
  u.d=d;
  return (u.l==0x7FF0000000000000ll?1:u.l==0xFFF0000000000000ll?-1:0);
}

Courtesy of dietlibc

Answer 4

看看这个浮点控件http://cibak.web.cern.ch/cibak/pval/valid.html