Comparación de coma flotante 0

Question

Si foo es de tipo flotante, ¿la siguiente expresión es válida/recomendada?

(0.0f == foo * float(0)) 

¿Tendrá el valor esperado (matemático) independientemente del valor de foo?

¿El estándar C++ define el comportamiento o es específico de la implementación?

Answer 1

yo sepa, no caerá necesariamente, también podría terminar muy cerca de 0.

En general, es mejor comparar contra un épsilon. Uso una función como esta para hacer tales comparaciones:

float EpsilonEqual(float a, float b, float epsilon) 
{ 
    return fabsf(a - b) < epsilon; 
} 

Answer 2

Bueno, en primer lugar no es realmente una cuestión de estándar C++. Más bien, lo que está en cuestión es su estándar de modelo de punto flotante (muy probablemente IEEE).

Para flotadores IEEE, probablemente sea seguro, ya que float(0) debería dar como resultado el mismo número que 0.0f, y el multiplicado por cualquier otro número también debería ser 0.0f.

Lo que no es realmente seguro es realizar otras operaciones de coma flotante (p. Ej .: suma y resta con números no enteros) y compararlas con 0.0f.

Answer 3

Con esa declaración en particular, puede estar bastante seguro de que el resultado será 0 y la comparación sea true - No pienso estándar de C++ en realidad lo receta, pero cualquier aplicación razonable de tipos de punto flotante tendrá 0 obra como ese.

Sin embargo, para la mayoría de otros cálculos, el resultado no puede se espera que sea exactamente igual a un literal del resultado matemáticamente correcto:

¿Por qué mis números, como 0,1 + 0,2 complemento hasta una buena ronda 0.3, y en su lugar me sale un resultado extraño como 0.30000000000000004?

Debido internamente, equipos utilizan un formato (binario de coma flotante) que no puede representar con precisión un número como 0,1, 0,2 o 0,3 en absoluto.

Cuando se compila el código o interpretado, su “0.1” es ya redondeado al número más cercano en ese formato , lo que resulta en una pequeña error de redondeo, incluso antes de que ocurra el cálculo .

Leer The Floating-Point Guide explicaciones detalladas y cómo hacerlo correctamente comparisons with expected values.

Answer 4

acabo de leer este artículo en MSDN acerca de la opción/fp en VisualStudio link text

optimizaciones de expresión que son válido para valores especiales (NAN, + infinito, -infinity, 0, -0) no será permitido.Las optimizaciones xx => 0, x * 0 => 0, x-0 => x, x + 0 => xy 0-x => -x no son válidos por varios motivos (consulte IEEE 754 y el estándar C99 ).

Answer 5

NaNs e Infinites pueden arruinar tales comparaciones, como otros ya han mencionado.

Sin embargo, hay otra trampa: en C++ no puede confiar en una expresión de tiempo de compilación de tipo flotante, comparando igual a la misma expresión evaluada en tiempo de ejecución.

El motivo es que C++ permite una mayor precisión para los cálculos de fp, de cualquier manera. Ejemplo:

#include <iostream> 

// This provides sufficent obfuscation so that g++ doesn't just inline results. 
bool obfuscatedTrue() { return true; } 

int main() 
{ 
    using namespace std; 

    double const a = (obfuscatedTrue()? 3.0 : 0.3); 
    double const b = (obfuscatedTrue()? 7.0 : 0.7); 
    double const c = a/b; 

    cout << (c == a/b? "OK." : "\"Wrong\" comparision result.") << endl; 
} 

Los resultados con un compilador en particular:

C:\test> g++ --version | find "++" 
g++ (TDM-2 mingw32) 4.4.1 

C:\test> g++ fp_comparision_problem.cpp & a 
"Wrong" comparision result. 

C:\test> g++ -O fp_comparision_problem.cpp & a 
OK. 

C:\test> _ 

Saludos & HTH,

- Alf