Si copio un flotante a otra variable, ¿serán iguales?

Sé que usar ==para verificar la igualdad de las variables de punto flotante no es una buena manera. Pero solo quiero saber eso con las siguientes declaraciones:

float x = ...

float y = x;

assert(y == x)

Como yse copia de x, ¿será cierta la afirmación?

Además del assert(NaN==NaN);caso señalado por kmdreko, puede tener situaciones con x87-math, cuando los flotantes de 80 bits se almacenan temporalmente en la memoria y luego se comparan con los valores que aún se almacenan dentro de un registro.

Posible ejemplo mínimo, que falla con gcc9.2 cuando se compila con -O2 -m32:

#include <cassert>

int main(int argc, char**){
    float x = 1.f/(argc+2);
    volatile float y = x;
    assert(x==y);
}

Demostración de Godbolt: https://godbolt.org/z/X-Xt4R

El volatileprobablemente se puede omitir, si logra crear suficientes registro a la presión de haber yalmacenado y vuelve a cargar desde la memoria (pero lo suficientemente confundir al compilador, no omitir la comparación todos juntos).

Consulte la referencia de preguntas frecuentes de GCC:

• ¿Por qué los resultados de punto flotante cambian con niveles de optimización o diferentes versiones del compilador o diferentes arquitecturas de destino?

No será cierto si xes así NaN, ya que las comparaciones NaNson siempre falsas (sí, incluso NaN == NaN). Para todos los demás casos (valores normales, valores subnormales, infinitos, ceros) esta afirmación será verdadera.

El consejo para evitar los ==flotantes se aplica a los cálculos debido a que los números de coma flotante no pueden expresar muchos resultados exactamente cuando se usan en expresiones aritméticas. La asignación no es un cálculo y no hay razón para que la asignación arroje un valor diferente al original.

La evaluación de precisión extendida no debería ser un problema si se sigue el estándar. De <cfloat>heredado de C [5.2.4.2.2.8] ( énfasis mío ):

A excepción de la asignación y la conversión (que eliminan todo el rango y la precisión adicionales) , los valores de las operaciones con operandos flotantes y valores sujetos a las conversiones aritméticas habituales y las constantes flotantes se evalúan en un formato cuyo rango y precisión pueden ser mayores que los requeridos por tipo.

Sin embargo, como los comentarios han señalado, algunos casos con ciertos compiladores, opciones de compilación y objetivos podrían hacer que esto sea paradójicamente falso.

Sí, yseguramente asumirá el valor de x:

[expr.ass]/2: En la asignación simple (=), el objeto al que hace referencia el operando izquierdo se modifica ([defns.access]) reemplazando su valor con el resultado del operando derecho.

No hay margen de maniobra para asignar otros valores.

^{(Otros ya han señalado que una comparación de equivalencia ==evaluará los falsevalores de NaN).}

El problema habitual con el punto flotante ==es que es fácil no tener el valor que crees que tienes. Aquí, sabemos que los dos valores, sean cuales sean, son los mismos.

Sí, en todos los casos (sin tener en cuenta los problemas de NaN y x87), esto será cierto.

Si haces una memcmpprueba en ellos, podrás probar la igualdad mientras comparas NaNs y sNaNs. Esto también requerirá que el compilador tome la dirección de la variable que coaccionará el valor a 32 bits en floatlugar de 80 bits. Esto eliminará los problemas x87. La segunda afirmación aquí pretende no mostrar que ==no comparará los NaN como verdaderos:

#include <cmath>
#include <cassert>
#include <cstring>

int main(void)
{
    float x = std::nan("");
    float y = x;
    assert(!std::memcmp(&y, &x, sizeof(float)));
    assert(y == x);
    return 0;
}

Tenga en cuenta que si los NaN tienen una representación interna diferente (es decir, una mantisa diferente), la memcmpcomparación no será verdadera.

En los casos habituales, se evaluaría como verdadero. (o la declaración de afirmación no hará nada)

Editar :

Por "casos habituales" me refiero a que estoy excluyendo los escenarios antes mencionados (como los valores de NaN y las unidades de punto flotante de 80x87) según lo señalado por otros usuarios.

Dada la obsolescencia de los chips 8087 en el contexto actual, el problema está bastante aislado y para que la pregunta sea aplicable en el estado actual de la arquitectura de punto flotante utilizada, es cierto para todos los casos, excepto para NaNs.

(referencia sobre 8087 - https://home.deec.uc.pt/~jlobo/tc/artofasm/ch14/ch143.htm )

Felicitaciones a @chtz por reproducir un buen ejemplo y a @kmdreko por mencionar NaNs: ¡no los conocíamos antes!

Sí, devolverá True siempre, excepto si es NaN . Si el valor de la variable es NaN , ¡siempre devuelve False !