Quelle est la meilleure façon de comparer des flottants pour une quasi-égalité en Python ?

Question

Il est bien connu que la comparaison des flottants pour l'égalité est un peu compliquée en raison des problèmes d'arrondi et de précision.

Par exemple : http://www.cygnus-software.com/papers/comparingfloats/comparingfloats.htm

Quelle est la méthode recommandée pour traiter ce problème en Python ?

Il existe sûrement une fonction de la bibliothèque standard pour cela quelque part ?

Answer 1

Est-ce que quelque chose d'aussi simple que ce qui suit n'est pas suffisant ?

return abs(f1 - f2) <= allowed_error

Answer 2

Je suis d'accord pour dire que la réponse de Gareth est probablement plus appropriée en tant que fonction/solution légère.

Mais j'ai pensé qu'il serait utile de noter que si vous utilisez numpy ou si vous l'envisagez, il existe une fonction packagée pour cela.

    numpy.isclose(a, b, rtol=1e-05, atol=1e-08, equal_nan=False)

Un petit avertissement cependant : l'installation de numpy peut être une expérience non triviale en fonction de votre plateforme.

Answer 3

Utilisez l'outil Python decimal qui fournit le module Decimal classe.

Dans les commentaires :

Il est intéressant de noter que si vous faites travail lourd en mathématiques et que vous n'avez pas absolument besoin de la précision de décimale, cela peut vraiment embourber les choses les choses. Les flottants sont beaucoup, beaucoup plus rapides à à traiter, mais imprécis. Les décimales sont extrêmement précises mais lentes.

Answer 4

L'idée reçue selon laquelle les nombres à virgule flottante ne peuvent pas être comparés pour vérifier leur égalité est inexacte. Les nombres à virgule flottante ne sont pas différents des nombres entiers : Si vous évaluez "a == b", vous obtiendrez vrai s'il s'agit de nombres identiques et faux sinon (étant entendu que deux NaN ne sont évidemment pas des nombres identiques).

Le problème réel est le suivant : Si j'ai effectué des calculs et que je ne suis pas sûr que les deux nombres que je dois comparer sont exactement corrects, que faire ? Ce problème est le même pour les nombres à virgule flottante que pour les nombres entiers. Si vous évaluez l'expression entière "7/3*3", la comparaison ne sera pas égale à "7*3/3".

Supposons donc que nous demandions "Comment comparer des entiers pour vérifier leur égalité" dans une telle situation. Il n'y a pas de réponse unique ; ce que vous devez faire dépend de la situation spécifique, notamment du type d'erreurs que vous avez et de ce que vous voulez obtenir.

Voici quelques choix possibles.

Si vous voulez obtenir un résultat "vrai" si les nombres mathématiquement exacts sont égaux, vous pouvez essayer d'utiliser les propriétés des calculs que vous effectuez pour prouver que vous obtenez les mêmes erreurs dans les deux nombres. Si cela est possible, et que vous comparez deux nombres résultant d'expressions qui donneraient des nombres égaux si elles étaient calculées exactement, alors vous obtiendrez un résultat "vrai" à partir de la comparaison. Une autre approche consiste à analyser les propriétés des calculs et à prouver que l'erreur ne dépasse jamais un certain montant, peut-être un montant absolu ou un montant relatif à l'une des entrées ou à l'une des sorties. Dans ce cas, vous pouvez demander si les deux nombres calculés diffèrent au maximum de cette quantité, et renvoyer "vrai" s'ils sont dans l'intervalle. Si vous ne pouvez pas prouver une limite d'erreur, vous pouvez deviner et espérer le meilleur. Une façon de le faire est d'évaluer de nombreux échantillons aléatoires et de voir quel type de distribution vous obtenez dans les résultats.

Bien sûr, puisque nous n'avons fixé comme condition que vous obteniez "true" si les résultats mathématiquement exacts sont égaux, nous avons laissé ouverte la possibilité que vous obteniez "true" même s'ils sont inégaux. (En fait, nous pouvons satisfaire l'exigence en retournant toujours "vrai". Cela rend le calcul simple mais n'est généralement pas souhaitable, je discuterai donc de l'amélioration de la situation ci-dessous).

Si vous voulez obtenir un résultat "faux" si les nombres mathématiquement exacts ne sont pas égaux, vous devez prouver que votre évaluation des nombres donne des nombres différents si les nombres mathématiquement exacts ne sont pas égaux. Cela peut être impossible à des fins pratiques dans de nombreuses situations courantes. Considérons donc une alternative.

Une condition utile pourrait être que nous obtenions un "faux" résultat si les nombres mathématiquement exacts diffèrent de plus d'une certaine quantité. Par exemple, nous allons peut-être calculer la trajectoire d'une balle lancée dans un jeu vidéo et nous voulons savoir si elle a touché une batte. Dans ce cas, nous voulons certainement obtenir la réponse "vrai" si la balle frappe la chauve-souris, et nous voulons obtenir la réponse "faux" si la balle est loin de la chauve-souris, et nous pouvons accepter une réponse "vrai" incorrecte si la balle, dans une simulation mathématiquement exacte, a manqué la chauve-souris mais est à un millimètre de la frapper. Dans ce cas, nous devons prouver (ou deviner/estimer) que notre calcul de la position de la balle et de la position de la chauve-souris a une erreur combinée d'au plus un millimètre (pour toutes les positions d'intérêt). Cela nous permettrait de toujours renvoyer "faux" si la balle et la batte sont séparées de plus d'un millimètre, de renvoyer "vrai" si elles se touchent, et de renvoyer "vrai" si elles sont suffisamment proches pour être acceptables.

Ainsi, la façon dont vous décidez ce qu'il faut retourner lorsque vous comparez des nombres à virgule flottante dépend beaucoup de votre situation spécifique.

Quant à la manière de prouver les limites d'erreur pour les calculs, cela peut être un sujet compliqué. Toute implémentation à virgule flottante utilisant la norme IEEE 754 en mode round-to-nearest renvoie le nombre à virgule flottante le plus proche du résultat exact pour toute opération de base (notamment la multiplication, la division, l'addition, la soustraction, la racine carrée). (En cas d'égalité, arrondissez de manière à ce que le bit le plus bas soit pair). (Faites particulièrement attention à la racine carrée et à la division ; l'implémentation de votre langage pourrait utiliser des méthodes non conformes à la norme IEEE 754 pour celles-ci). Grâce à cette exigence, nous savons que l'erreur dans un seul résultat est au plus égale à la moitié de la valeur du bit le moins significatif. (Si c'était plus, l'arrondi serait passé à un autre nombre qui se situe dans la moitié de la valeur).

La suite devient nettement plus compliquée ; l'étape suivante consiste à effectuer une opération dont l'une des entrées comporte déjà une erreur. Pour les expressions simples, ces erreurs peuvent être suivies tout au long des calculs pour atteindre une limite sur l'erreur finale. Dans la pratique, cela ne se fait que dans quelques situations, comme le travail sur une bibliothèque de mathématiques de haute qualité. Et, bien sûr, vous avez besoin d'un contrôle précis sur les opérations qui sont effectuées. Les langages de haut niveau laissent souvent beaucoup de latitude au compilateur, de sorte que vous pouvez ne pas savoir dans quel ordre les opérations sont effectuées.

On pourrait écrire (et on écrit) beaucoup plus sur ce sujet, mais je dois m'arrêter là. En résumé, la réponse est la suivante : Il n'existe pas de routine de bibliothèque pour cette comparaison parce qu'il n'y a pas de solution unique qui réponde à la plupart des besoins et qui vaille la peine d'être intégrée dans une routine de bibliothèque. (Si la comparaison avec un intervalle d'erreur relatif ou absolu vous suffit, vous pouvez le faire simplement sans routine de bibliothèque).

Answer 5

Je ne suis pas au courant de quoi que ce soit dans la bibliothèque standard de Python (ou ailleurs) qui implémente la méthode de Dawson. AlmostEqual2sComplement fonction. Si c'est le type de comportement que vous souhaitez, vous devrez l'implémenter vous-même. (Dans ce cas, plutôt que d'utiliser les astuces de Dawson, vous feriez sans doute mieux d'utiliser des tests plus conventionnels de type if abs(a-b) <= eps1*(abs(a)+abs(b)) + eps2 ou similaire. Pour obtenir un comportement similaire à celui de Dawson, vous pouvez dire quelque chose comme if abs(a-b) <= eps*max(EPS,abs(a),abs(b)) pour un petit nombre de valeurs fixes EPS Ce n'est pas exactement la même chose que Dawson, mais c'est similaire dans l'esprit.