Cálculos en coma flotante IEEE-754, igualdad y estrechamiento

Question

En el siguiente código, las funciones foo1, foo2 y foo3 son equivalentes. Sin embargo, cuando ejecutar foo3 no termina desde el ciclo, ¿hay alguna razón por la cual este sea el caso?

template <typename T> 
T foo1() 
{ 
    T x = T(1); 
    T y = T(0); 
    for (;;) 
    { 
     if (x == y) break; 
     y = x; 
     ++x; 
    } 
    return x; 
} 

template <typename T> 
T foo2() 
{ 
    T x = T(0); 
    for (;;) 
    { 
     T y = x + T(1); 
     if (!(x != y)) break; 
     ++x; 
    } 
    return x; 
} 

template <typename T> 
T foo3() 
{ 
    T x = T(0); 
    while (x != (x + T(1))) ++x; 
    return x; 
} 

int main() 
{ 
    printf("1 float: %20.5f\n", foo1<float>()); 
    printf("2 float: %20.5f\n", foo2<float>()); 
    printf("3 float: %20.5f\n", foo3<float>()); 
    return 0; 
} 

Nota: Este fue compilado usando VS2010 con/fp precisa en modo de lanzamiento. No estoy seguro de cómo GCC, etc. trataría este código, cualquier información sería genial. ¿Podría ser esto un problema donde en foo3, los valores x y x + 1 se convierten en NaN de alguna manera?

Answer 1

Lo que sucede es muy probablemente lo siguiente. En el arco x86, los cálculos intermedios se pueden realizar con 80 bits de precisión (el doble largo es el tipo correspondiente de C/C++). El compilador usa todos los 80 bits para la operación (+1) y para la operación (! =), Pero trunca los resultados antes del almacenamiento.

Así que lo que su compilador que realmente hace es la siguiente:

while ((long double)(x) != ((long double)(x) + (long double)(1))) { 
    x = (float)((long double)(x) + (long double)(1)); 
} 

Esto es absolutamente no-IEEE-conformes y provoca un sinfín de dolores de cabeza para todos, pero este es el valor predeterminado para MSVC. Use el indicador del compilador /fp:strict para deshabilitar este comportamiento.

Este es mi recuerdo del problema de hace unos 10 años, así que por favor, perdónenme si esto de alguna manera no es del todo correcto. See this for the official Microsoft documentation.

EDITAR I era muy sorprenda al saber que g ++ de exposiciones predeterminados exactamente el mismo comportamiento (en Linux i386, pero no con por ejemplo -mfpmath = sse).