Comment correctement et correctement comparer les flotteurs?

De La Virgule Flottante Guide:

C'est une mauvaise façon de le faire, car un
fixe epsilon choisi parce qu'il “semble
petit” pourrait en fait être beaucoup trop grande
lorsque les chiffres comparés sont
très petite. La comparaison
retourne “true” pour les nombres
sont tout à fait différents. Et lorsque l'
les numéros sont très grandes, les epsilon
pourrait être plus petite que la
la plus petite erreur d'arrondi, de sorte que le
la comparaison renvoie toujours “false”.

Le problème avec le "nombre magique" n'est pas ici que c'est codé en dur, mais que c'est "magique": vous n'avez pas vraiment avoir une raison pour le choix de 0.000001 sur 0.000005 ou 0.0000000000001, avez-vous? Notez que float peut représenter approximativement la dernière et la plus petite des valeurs - c'est à peu près 7 décimales de précision après le premier chiffre différent de zéro!

Si vous allez utiliser un fixe epsilon, vous devriez vraiment choisir en fonction des exigences de la pièce, en particulier, de code où vous l'utilisez. L'alternative est d'utiliser une relative marge d'erreur (voir le lien en haut pour les détails) ou, encore mieux, ou comparer les chars comme des entiers.

Vous devez être conscient que si vous êtes à la comparaison de deux flotteurs pour l'égalité, vous
sont intrinsèquement de faire la mauvaise chose. L'ajout d'un retraité facteur de la comparaison
n'est pas assez bon.

Merci pour vos réponses, elles m'ont beaucoup aidé. J'ai lu ces documents:première et deuxième

La réponse est d'utiliser mon propre fonction pour comparaison:

bool areEqualRel(float a, float b, float epsilon) {
    return (fabs(a - b) <= epsilon * std::max(fabs(a), fabs(b)));
}

C'est la solution la plus adaptée à mes besoins. Cependant j'ai écrit quelques essais et d'autres méthodes de comparaison. J'espère que ce sera utile à quelqu'un. areEqualRel passe ces tests, d'autres ne le font pas.

#include <iostream>
#include <limits>
#include <algorithm>
using std::cout;
using std::max;
bool areEqualAbs(float a, float b, float epsilon) {
return (fabs(a - b) <= epsilon);
}
bool areEqual(float a, float b, float epsilon) {
return (fabs(a - b) <= epsilon * std::max(1.0f, std::max(a, b)));
}
bool areEqualRel(float a, float b, float epsilon) {
return (fabs(a - b) <= epsilon * std::max(fabs(a), fabs(b)));
}
int main(int argc, char *argv[])
{
cout << "minimum: " << FLT_MIN      << "\n";
cout << "maximum: " << FLT_MAX      << "\n";
cout << "epsilon: " << FLT_EPSILON  << "\n";
float a = 0.0000001f;
float b = 0.0000002f;
if (areEqualRel(a, b, FLT_EPSILON)) {
cout << "are equal a: " << a << " b: " << b << "\n";
}
a = 1000001.f;
b = 1000002.f;
if (areEqualRel(a, b, FLT_EPSILON)) {
cout << "are equal a: " << a << " b: " << b << "\n";
}
}

Ici est un c++11 de la mise en œuvre de @geotavros 's solution. Il fait usage de la nouvelle std::numeric_limits<T>::epsilon() fonction et le fait que std::fabs() et std::fmax() maintenant ont des surcharges pour float, double et long float.

template<typename T>
static bool AreEqual(T f1, T f2) { 
return (std::fabs(f1 - f2) <= std::numeric_limits<T>::epsilon() * std::fmax(std::fabs(f1), std::fabs(f2)));
}