Comparer les doubles

Ici est de savoir comment je test d'égalité, sans un "facteur":

if (
    //Test 1: Very cheap, but can result in false negatives
    a==b || 
    //Test 2: More expensive, but comprehensive
    std::abs(a-b)<std::abs(std::min(a,b))*std::numeric_limits<double>::epsilon())
  std::cout << "The numbers are equal\n";

Explication

Le premier test est une simple comparaison. Bien sûr, nous savons tous que la comparaison des valeurs de double précision peut être jugée inégale, même quand ils sont logiquement équivalentes.

Un double précision en virgule flottante valeur peut tenir le plus important de quinze chiffres d'un nombre (en fait ≈15.955 chiffres). Par conséquent, nous voulons appeler deux valeurs égales si (environ) de leurs quinze premiers chiffres correspondent. À cette phrase d'une autre manière, nous voulons appeler égales si elles sont à une échelle epsilon les uns des autres. C'est exactement ce que le deuxième test calcule.

Vous pouvez choisir d'ajouter plus de marge de manœuvre que d'une seule échelle epsilon, en raison des plus importants à virgule flottante erreurs qui se glissent dans la suite de itératif de calcul. Pour ce faire, ajoutez un facteur d'erreur à la droite de la deuxième test de comparaison:

double error_factor=2.0;

if (a==b ||         
    std::abs(a-b)<std::abs(std::min(a,b))*std::numeric_limits<double>::epsilon()*
                  error_factor)
  std::cout << "The numbers are equal\n";

Je ne peux pas vous donner une valeur fixe pour le error_factorcar il dépendra de la quantité d'erreur qui se glisse dans vos calculs. Cependant, avec quelques essais, vous devriez être en mesure de trouver une valeur raisonnable qui convient à votre application. Ne gardez à l'esprit que l'ajout d'un (arbitraire) le facteur d'erreur basé sur la spéculation seul qui va vous mettre le droit de retour dans le fudge factor territoire.

Résumé

Vous pouvez envelopper le test suivant dans un(n inline) fonction:

inline bool logically_equal(double a, double b, double error_factor=1.0)
{
  return a==b || 
    std::abs(a-b)<std::abs(std::min(a,b))*std::numeric_limits<double>::epsilon()*
                  error_factor;
}

Il suffit de tester si la différence est de moins de ce montant 🙂

if ( std::abs(a - b) < 1.0 / 10000000 )
  cout << "The numbers are almost equal.\n";

Si vous voulez le tester à l'échelle avec a et b, vous pouvez essayer de tester l'abs(a/b-1) < e, où e est votre favori petit nombre, comme de 0,001. Mais cette condition est en fait asymétrique en a et b, donc il peut travailler à dire que a est proche de b, mais b n'est pas proche de un. Ce serait mauvais. Il est mieux de le faire en abs(log(a/b)) < e, où e, de nouveau, est votre favori très petit nombre. Mais les logarithmes présent supplément de calcul, pour ne pas mentionner terrifiant des étudiants de premier cycle partout.

Je propose l'article suivant: nouveau lien
(obsolète lien->La comparaison des nombres à virgule flottante)