Si je copie un flottant dans une autre variable, sera-t-il égal?

Je sais que l'utilisation ==pour vérifier l'égalité des variables à virgule flottante n'est pas un bon moyen. Mais je veux juste savoir cela avec les déclarations suivantes:

float x = ...

float y = x;

assert(y == x)

Puisque yest copié de x, l'affirmation sera-t-elle vraie?

Outre le assert(NaN==NaN);cas souligné par kmdreko, vous pouvez avoir des situations avec x87-math, lorsque des flottants 80 bits sont temporairement stockés en mémoire et plus tard comparés à des valeurs qui sont toujours stockées dans un registre.

Exemple minimal possible, qui échoue avec gcc9.2 lorsqu'il est compilé avec -O2 -m32:

#include <cassert>

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

Démo Godbolt: https://godbolt.org/z/X-Xt4R

Le volatilepeut probablement être omis, si vous parvenez à créer une pression de registre suffisante pour avoir ystocké et rechargé à partir de la mémoire (mais confondez suffisamment le compilateur, pour ne pas omettre la comparaison).

Voir la référence de la FAQ GCC:

• Pourquoi les résultats en virgule flottante changent avec des niveaux d'optimisation ou différentes versions de compilateur ou différentes architectures cibles?

Ce ne sera pas vrai si xc'est le cas NaN, car les comparaisons sur NaNsont toujours fausses (oui, même NaN == NaN). Pour tous les autres cas (valeurs normales, valeurs sous-normales, infinis, zéros), cette affirmation sera vraie.

Les conseils pour éviter les ==flottants s'appliquent aux calculs car les nombres à virgule flottante sont incapables d'exprimer de nombreux résultats exactement lorsqu'ils sont utilisés dans des expressions arithmétiques. L'affectation n'est pas un calcul et il n'y a aucune raison pour que l'affectation produise une valeur différente de l'original.

L'évaluation à précision étendue ne devrait pas poser de problème si la norme est respectée. De <cfloat>hérité de C [5.2.4.2.2.8] ( soulignement le mien ):

À l'exception de l'affectation et de la conversion (qui supprime toute plage et précision supplémentaires) , les valeurs des opérations avec des opérandes flottants et les valeurs soumises aux conversions arithmétiques habituelles et des constantes flottantes sont évaluées dans un format dont la plage et la précision peuvent être supérieures à celles requises par le type.

Cependant, comme l'ont souligné les commentaires, certains cas avec certains compilateurs, options de build et cibles pourraient rendre cela paradoxalement faux.

Oui, yprendra assurément la valeur de x:

[expr.ass]/2: En affectation simple (=), l'objet référencé par l'opérande gauche est modifié ([defns.access]) en remplaçant sa valeur par le résultat de l'opérande droit.

Il n'y a pas de latitude pour attribuer d'autres valeurs.

^{(D'autres ont déjà souligné qu'une comparaison d'équivalence ==sera néanmoins évaluée falsepour les valeurs de NaN.)}

Le problème habituel avec la virgule flottante ==est qu'il est facile de ne pas avoir la valeur que vous pensez avoir. Ici, nous savons que les deux valeurs, quelles qu'elles soient, sont identiques.

Oui, dans tous les cas (sans tenir compte des problèmes NaN et x87), cela sera vrai.

Si vous faites un memcmpsur eux, vous pourrez tester l'égalité tout en étant capable de comparer les NaN et les sNaN. Cela nécessitera également que le compilateur prenne l'adresse de la variable qui contraindra la valeur en 32 bits floatau lieu de 80 bits. Cela éliminera les problèmes de x87. La deuxième affirmation ici est destinée à ne pas montrer que ==les NaN ne seront pas comparés comme vrais:

#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;
}

Notez que si les NaN ont une représentation interne différente (c'est-à-dire une mantisse différente), la valeur memcmpne sera pas vraie.

Dans les cas habituels, il serait évalué comme vrai. (ou l'instruction assert ne fera rien)

Modifier :

Par «cas habituels», j'entends exclure les scénarios susmentionnés (tels que les valeurs NaN et les unités à virgule flottante 80x87), comme indiqué par d'autres utilisateurs.

Étant donné l'obsolescence des puces 8087 dans le contexte actuel, le problème est plutôt isolé et pour que la question soit applicable dans l'état actuel de l'architecture à virgule flottante utilisée, elle est vraie dans tous les cas, sauf pour les NaN.

(référence environ 8087 - https://home.deec.uc.pt/~jlobo/tc/artofasm/ch14/ch143.htm )

Félicitations à @chtz pour avoir reproduit un bon exemple et @kmdreko pour avoir mentionné les NaN - ne les connaissaient pas avant!

Oui, il retournera toujours True , sauf si c'est NaN . Si la valeur de la variable est NaN, elle renvoie toujours False !