Comment dois-je faire floating point de comparaison?

J'ai eu le problème de la Comparaison des nombres à virgule flottante A < B et A > B
Voici ce qui semble fonctionner:

if(A - B < Epsilon) && (fabs(A-B) > Epsilon)
{
    printf("A is less than B");
}

if (A - B > Epsilon) && (fabs(A-B) > Epsilon)
{
    printf("A is greater than B");
}

La fab--valeur absolue-- prend en charge s'ils sont essentiellement égaux.

TL;DR

• Utiliser la fonction suivante au lieu de la solution retenue pour éviter des résultats indésirables dans certains cas limites, tout en étant potentiellement plus efficace.
• Connait la imprécision que vous avez sur vos numéros et de les nourrir en conséquence dans la fonction de comparaison.

bool nearly_equal(
  float a, float b,
  float epsilon = 128 * FLT_EPSILON, float relth = FLT_MIN)
  //those defaults are arbitrary and could be removed
{
  assert(std::numeric_limits<float>::epsilon() <= epsilon);
  assert(epsilon < 1.f);

  if (a == b) return true;

  auto diff = std::abs(a-b);
  auto norm = std::min((std::abs(a) + std::abs(b)), std::numeric_limits<float>::max());
  return diff < std::max(relth, epsilon * norm);
}

Graphiques, s'il vous plaît?

Lors de la comparaison des nombres à virgule flottante, il y a deux "modes".

Le premier est le relative mode, d'où la différence entre x et y est considéré comme étant relativement à leur amplitude |x| + |y|. Lors de la parcelle en 2D, il donne le profil suivant, où le vert signifie l'égalité de x et y. (J'ai pris un epsilon de 0,5 à des fins d'illustration).

Le mode relatif est ce qui est utilisé pour "normal" ou "assez grand" floating points des valeurs. (Plus sur cela plus tard).

Le deuxième est un absolue mode, quand il suffit de comparer leur différence d'un nombre fixe. Il donne le profil suivant (de nouveau avec un epsilon de 0.5 et une relth de 1 pour l'illustration).

Ce mode absolu de comparaison est ce qui est utilisé pour les "petites" valeurs à virgule flottante.

Maintenant, la question est, comment pouvons-nous combiner ces deux schémas de réponse.

Michael Borgwardt réponse, le commutateur est basé sur la valeur de diff, qui devrait être en dessous de relth (Float.MIN_NORMAL dans sa réponse). Ce commutateur horaire est indiqué éclos dans le graphique ci-dessous.

Parce que relth * epsilon est plus petit que relth, les taches vertes ne collent pas ensemble, qui à son tour donne la solution d'un mauvais propriété: on peut trouver des triplets de nombres tels que x < y_1 < y_2 et pourtant x == y2 mais x != y1.

Prendre cet exemple frappant:

x  = 4.9303807e-32
y1 = 4.930381e-32
y2 = 4.9309825e-32

Nous avons x < y1 < y2, et en fait y2 - x est plus de 2000 fois plus grande que y1 - x. Et pourtant, avec la solution actuelle,

nearlyEqual(x, y1, 1e-4) == False
nearlyEqual(x, y2, 1e-4) == True

En revanche, dans la solution proposée ci-dessus, l'interrupteur horaire est basé sur la valeur de |x| + |y|, qui est représenté par la éclos carré ci-dessous. Il assure que les deux zones se connecte normalement.

Aussi, le code ci-dessus n'ont pas de branchement, qui pourrait être plus efficace. Considérer que les opérations telles que max et abs, qui a priori besoins de ramification, souvent, ont consacré des instructions de montage. Pour cette raison, je pense que cette approche est supérieure à une autre solution qui consisterait à fixer Michael nearlyEqual en changeant le commutateur de diff < relth à diff < eps * relth, qui serait alors de produire essentiellement le même profil de réponse.

Où pour basculer entre relatif et absolu de comparaison?

Le basculer entre ces deux modes est faite autour de relth, qui est considéré comme FLT_MIN dans la accepté de répondre. Ce choix signifie que la représentation de float32 est ce qui limite la précision de nos nombres en virgule flottante.

Ce n'est pas toujours logique. Par exemple, si les numéros de comparer les résultats d'une soustraction, peut-être quelque chose dans la gamme de FLT_EPSILON a plus de sens. S'ils sont carrés des racines de la soustrait des nombres, le numérique imprécision pourrait être encore plus élevé.

Il est plutôt évident lorsque l'on considère les comparant à virgule flottante avec 0. Ici, un parent, une comparaison sera un échec, car |x - 0| /(|x| + 0) = 1. De sorte que la comparaison doit basculer en mode absolu quand x est de l'ordre de l'imprécision de votre calcul -- et il est rarement aussi bas que FLT_MIN.

C'est la raison de l'introduction de la relth paramètre ci-dessus.

Aussi, en ne multipliant relth avec epsilon, l'interprétation de ce paramètre est simple et en adéquation avec le niveau de précision numérique que nous attendons de ces chiffres.

Mathématique grondement

(ici surtout pour mon propre plaisir)

Plus généralement, je pense qu'un bon comportement de virgule flottante opérateur de comparaison =~ doit avoir certaines propriétés de base.

Suivantes sont assez évidentes:

• auto-égalité: a =~ a
• symétrie: a =~ b implique b =~ a
• invariance par l'opposition: a =~ b implique -a =~ -b

(Nous n'avons pas a =~ b et b =~ c implique a =~ c, =~ n'est pas une relation d'équivalence).

Je voudrais ajouter les propriétés suivantes qui sont plus spécifiques à virgule flottante comparaisons

• si a < b < c, puis a =~ c implique a =~ b (plus proche des valeurs devraient également être égaux)
• si a, b, m >= 0 puis a =~ b implique a + m =~ b + m (plus les valeurs avec la même différence devrait également être égaux)
• si 0 <= λ < 1 puis a =~ b implique λa =~ λb (peut-être moins évidente à l'argument pour).

Ces propriétés donnent déjà de fortes contraintes sur possible la quasi-égalité des fonctions. La fonction proposée ci-dessus, les vérifie. Peut-être un ou plusieurs évidente propriétés sont manquantes.

Quand on pense à =~ comme une famille de l'égalité relation =~[Ɛ,t] paramétré par Ɛ et relth, on pourrait également ajouter

• si Ɛ1 < Ɛ2 puis a =~[Ɛ1,t] b implique a =~[Ɛ2,t] b (égalité pour une tolérance implique l'égalité à une plus grande tolérance)
• si t1 < t2 puis a =~[Ɛ,t1] b implique a =~[Ɛ,t2] b (égalité pour une imprécision implique l'égalité à une plus grande imprécision)

La solution proposée permet également de vérifier ces.

Adaptation à PHP de Michael Borgwardt & bosonix réponse:

class Comparison
{
    const MIN_NORMAL = 1.17549435E-38;  //from Java Specs

    //from http://floating-point-gui.de/errors/comparison/
    public function nearlyEqual($a, $b, $epsilon = 0.000001)
    {
        $absA = abs($a);
        $absB = abs($b);
        $diff = abs($a - $b);

        if ($a == $b) {
            return true;
        } else {
            if ($a == 0 || $b == 0 || $diff < self::MIN_NORMAL) {
                return $diff < ($epsilon * self::MIN_NORMAL);
            } else {
                return $diff / ($absA + $absB) < $epsilon;
            }
        }
    }
}

Vous devriez vous demander pourquoi vous comparez les chiffres. Si vous savez le but de la comparaison, alors vous devez également savoir la précision requise de vos numéros. C'est différent dans chaque situation et de chaque contexte d'application. Mais dans presque tous les cas pratiques, il est nécessaire absolue précision. Il n'est que très rarement qu'une précision relative est applicable.

Pour donner un exemple: si votre but est de dessiner un graphique sur l'écran, alors vous avez probablement envie de valeurs à virgule flottante de comparer égaux s'ils correspondent à la même pixel sur l'écran. Si la taille de votre écran est de 1000 pixels, et vos numéros sont dans le 1e6 plage, alors il est probable que vous voudrez 100 à comparer égal à 200.

Compte tenu de la nécessaire précision absolue, alors l'algorithme devient:

public static ComparisonResult compare(float a, float b, float accuracy) 
{
    if (isnan(a) || isnan(b))   //if NaN needs to be supported
        return UNORDERED;    
    if (a == b)                 //short-cut and takes care of infinities
        return EQUAL;           
    if (abs(a-b) < accuracy)    //comparison wrt. the accuracy
        return EQUAL;
    if (a < b)                  //larger /smaller
        return SMALLER;
    else
        return LARGER;
}

Conseillé de le faire est d'utiliser quelques petits "epsilon" de la valeur (choisi en fonction de votre application, probablement), et d'envisager des flotteurs qui sont dans l'epsilon de l'autre pour être égaux. par exemple, quelque chose comme

#define EPSILON 0.00000001

if ((a - b) < EPSILON && (b - a) < EPSILON) {
  printf("a and b are about equal\n");
}

Une réponse plus complète est compliqué, car à virgule flottante d'erreur est extrêmement subtil et déroutant à la raison. Si vous vous souciez vraiment de l'égalité dans tous les sens précis, vous êtes probablement à la recherche d'une solution qui n'implique pas de virgule flottante.