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

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

Par exemple: https://randomascii.wordpress.com/2012/02/25/comparing-floating-point-numbers-2012-edition/

Quelle est la méthode recommandée pour gérer cela en Python?

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

Python 3.5 ajoute les fonctions math.iscloseetcmath.isclose comme décrit dans PEP 485 .

Si vous utilisez une version antérieure de Python, la fonction équivalente est donnée dans la documentation .

def isclose(a, b, rel_tol=1e-09, abs_tol=0.0):
    return abs(a-b) <= max(rel_tol * max(abs(a), abs(b)), abs_tol)

rel_tolest une tolérance relative, elle est multipliée par la plus grande des grandeurs des deux arguments; au fur et à mesure que les valeurs deviennent plus grandes, la différence permise entre elles tout en les considérant comme égales.

abs_tolest une tolérance absolue qui est appliquée telle quelle dans tous les cas. Si la différence est inférieure à l'une ou l'autre de ces tolérances, les valeurs sont considérées comme égales.

Est-ce que quelque chose d'aussi simple que le suivant n'est pas assez bon?

return abs(f1 - f2) <= allowed_error

Je conviens que la réponse de Gareth est probablement la 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 envisagez de le faire, 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 selon votre plate-forme.

Utilisez le decimalmodule de Python , qui fournit la Decimalclasse.

D'après les commentaires:

Il convient de noter que si vous effectuez un travail mathématique et que vous n'avez pas absolument besoin de la précision décimale, cela peut vraiment gâcher les choses. Les flotteurs sont beaucoup plus rapides à gérer, mais imprécis. Les décimales sont extrêmement précises mais lentes.

Je ne connais rien dans la bibliothèque standard de Python (ou ailleurs) qui implémente la AlmostEqual2sComplementfonction de Dawson . Si c'est le genre de comportement que vous souhaitez, vous devrez l'implémenter vous-même. (Dans ce cas, plutôt que d'utiliser les hacks intelligents au niveau du bit de Dawson, vous feriez probablement mieux d'utiliser des tests plus conventionnels de la forme if abs(a-b) <= eps1*(abs(a)+abs(b)) + eps2ou similaire. Pour obtenir un comportement semblable à Dawson, vous pourriez dire quelque chose comme if abs(a-b) <= eps*max(EPS,abs(a),abs(b))pour certains petits correctifs EPS; ce n'est pas exactement la même chose que Dawson, mais son esprit est similaire.

La sagesse courante selon laquelle les nombres à virgule flottante ne peuvent pas être comparés pour l'égalité est inexacte. Les nombres à virgule flottante ne sont pas différents des entiers: si vous évaluez "a == b", vous obtiendrez vrai si ce sont des nombres identiques et faux sinon (étant entendu que deux NaN ne sont bien sûr pas des nombres identiques).

Le vrai problème est le suivant: si j'ai fait quelques calculs et que je ne suis pas sûr que les deux chiffres que je dois comparer sont exactement corrects, alors quoi? Ce problème est le même pour les virgules flottantes que pour les entiers. Si vous évaluez l'expression entière "7/3 * 3", elle ne sera pas comparable à "7 * 3/3".

Supposons donc que nous ayons demandé "Comment comparer les entiers pour l'é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 souhaitez 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 qui résultent d'expressions qui donneraient des nombres égaux s'ils étaient calculés exactement, alors vous obtiendrez «vrai» 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 d'au plus ce montant et renvoyer "vrai" s'ils se trouvent dans l'intervalle. Si vous ne pouvez pas prouver une erreur liée, vous pourriez deviner et espérer le meilleur. Une façon de deviner 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 ne fixons l'exigence que vous devenez "vrai" que si les résultats mathématiquement exacts sont égaux, nous avons laissé ouverte la possibilité que vous obteniez "vrai" 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, donc je vais discuter de l'amélioration de la situation ci-dessous.)

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

Une condition utile pourrait être d'obtenir un résultat "faux" si les nombres mathématiquement exacts diffèrent de plus d'un certain montant. Par exemple, nous allons peut-être calculer où une balle lancée dans un jeu vidéo a voyagé, et nous voulons savoir si elle a frappé une batte. Dans ce cas, nous voulons certainement obtenir "vrai" si la balle frappe la batte, et nous voulons obtenir "faux" si la balle est loin de la batte, et nous pouvons accepter une réponse "vraie" incorrecte si la balle dans une simulation mathématiquement exacte a raté la chauve-souris, mais se situe à un millimètre près de la frappe. Dans ce cas, nous devons prouver (ou deviner / estimer) que notre calcul de la position de la balle et de la position de la batte a une erreur combinée d'au plus un millimètre (pour toutes les positions d'intérêt). Cela nous permettrait de toujours revenir "

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

Quant à la façon dont vous allez prouver les limites d'erreur pour les calculs, cela peut être un sujet compliqué. Toute implémentation en virgule flottante utilisant la norme IEEE 754 en mode arrondi au plus proche renvoie le nombre à virgule flottante le plus proche du résultat exact pour toute opération de base (notamment multiplication, division, addition, soustraction, racine carrée). (En cas d'égalité, arrondissez pour que le bit faible soit égal.) (Faites particulièrement attention à la racine carrée et à la division; l'implémentation de votre langage peut utiliser des méthodes qui ne sont pas conformes à IEEE 754 pour celles-ci.) En raison de cette exigence, nous connaissons la l'erreur dans un seul résultat représente au plus la moitié de la valeur du bit le moins significatif. (Si c'était plus, l'arrondi serait allé à un nombre différent qui est dans la moitié de la valeur.)

Partir de là devient beaucoup plus compliqué; l'étape suivante exécute une opération où l'une des entrées a déjà une erreur. Pour les expressions simples, ces erreurs peuvent être suivies à travers les calculs pour atteindre une limite sur l'erreur finale. En 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 exactement quelles opérations sont effectuées. Les langages de haut niveau donnent souvent beaucoup de mou au compilateur, vous ne savez donc peut-être pas dans quel ordre les opérations sont effectuées.

Il y a beaucoup plus qui pourrait être (et est) écrit sur ce sujet, mais je dois m'arrêter là. En résumé, la réponse est: il n'y a pas de routine de bibliothèque pour cette comparaison, car il n'y a pas de solution unique qui réponde à la plupart des besoins qui mérite d'être mise 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.)

Si vous voulez l'utiliser dans le contexte testing / TDD, je dirais que c'est une manière standard:

from nose.tools import assert_almost_equals

assert_almost_equals(x, y, places=7) #default is 7

math.isclose () a été ajouté à Python 3.5 pour cela ( code source ). Voici un portage de celui-ci vers Python 2. Sa différence avec une ligne de Mark Ransom est qu'il peut gérer "inf" et "-inf" correctement.

def isclose(a, b, rel_tol=1e-09, abs_tol=0.0):
    '''
    Python 2 implementation of Python 3.5 math.isclose()
    https://hg.python.org/cpython/file/tip/Modules/mathmodule.c#l1993
    '''
    # sanity check on the inputs
    if rel_tol < 0 or abs_tol < 0:
        raise ValueError("tolerances must be non-negative")

    # short circuit exact equality -- needed to catch two infinities of
    # the same sign. And perhaps speeds things up a bit sometimes.
    if a == b:
        return True

    # This catches the case of two infinities of opposite sign, or
    # one infinity and one finite number. Two infinities of opposite
    # sign would otherwise have an infinite relative tolerance.
    # Two infinities of the same sign are caught by the equality check
    # above.
    if math.isinf(a) or math.isinf(b):
        return False

    # now do the regular computation
    # this is essentially the "weak" test from the Boost library
    diff = math.fabs(b - a)
    result = (((diff <= math.fabs(rel_tol * b)) or
               (diff <= math.fabs(rel_tol * a))) or
              (diff <= abs_tol))
    return result

J'ai trouvé la comparaison suivante utile:

str(f1) == str(f2)

Dans certains cas où vous pouvez affecter la représentation du numéro source, vous pouvez les représenter sous forme de fractions au lieu de flottants, en utilisant un numérateur et un dénominateur entiers. De cette façon, vous pouvez avoir des comparaisons exactes.

Voir le module Fraction de fractions pour plus de détails.

J'ai aimé la suggestion de @Sesquipedal mais avec des modifications (un cas d'utilisation spécial lorsque les deux valeurs sont 0 renvoie False). Dans mon cas, j'étais sur Python 2.7 et j'utilisais juste une fonction simple:

if f1 ==0 and f2 == 0:
    return True
else:
    return abs(f1-f2) < tol*max(abs(f1),abs(f2))

Utile dans le cas où vous voulez vous assurer que 2 nombres sont identiques 'jusqu'à la précision', pas besoin de spécifier la tolérance:

• Trouver la précision minimale des 2 nombres

• Arrondissez les deux à une précision minimale et comparez

def isclose(a,b):                                       
    astr=str(a)                                         
    aprec=len(astr.split('.')[1]) if '.' in astr else 0 
    bstr=str(b)                                         
    bprec=len(bstr.split('.')[1]) if '.' in bstr else 0 
    prec=min(aprec,bprec)                                      
    return round(a,prec)==round(b,prec)                               

Tel qu'il est écrit, ne fonctionne que pour les nombres sans le «e» dans leur représentation sous forme de chaîne (ce qui signifie 0,9999999999995e-4 <nombre <= 0,9999999999995e11)

Exemple:

>>> isclose(10.0,10.049)
True
>>> isclose(10.0,10.05)
False

Pour comparer jusqu'à une décimale donnée sans atol/rtol:

def almost_equal(a, b, decimal=6):
    return '{0:.{1}f}'.format(a, decimal) == '{0:.{1}f}'.format(b, decimal)

print(almost_equal(0.0, 0.0001, decimal=5)) # False
print(almost_equal(0.0, 0.0001, decimal=4)) # True 

C'est peut-être un hack un peu moche, mais cela fonctionne assez bien lorsque vous n'avez pas besoin de plus que la précision de flottement par défaut (environ 11 décimales).

La fonction round_to utilise la méthode de format de la classe str intégrée pour arrondir le flottant à une chaîne qui représente le flottant avec le nombre de décimales nécessaires, puis applique la fonction intégrée eval à la chaîne flottante arrondie pour revenir au type numérique flottant.

La fonction is_close applique simplement une conditionnelle simple au flottant arrondi.

def round_to(float_num, prec):
    return eval("'{:." + str(int(prec)) + "f}'.format(" + str(float_num) + ")")

def is_close(float_a, float_b, prec):
    if round_to(float_a, prec) == round_to(float_b, prec):
        return True
    return False

>>>a = 10.0
10.0
>>>b = 10.0001
10.0001
>>>print is_close(a, b, prec=3)
True
>>>print is_close(a, b, prec=4)
False

Mettre à jour:

Comme suggéré par @stepehjfox, un moyen plus propre de construire une fonction rount_to en évitant "eval" utilise le formatage imbriqué :

def round_to(float_num, prec):
    return '{:.{precision}f}'.format(float_num, precision=prec)

En suivant la même idée, le code peut être encore plus simple en utilisant les nouvelles grandes chaînes f (Python 3.6+):

def round_to(float_num, prec):
    return f'{float_num:.{prec}f}'

Donc, nous pourrions même tout résumer dans une fonction simple et propre 'is_close' :

def is_close(a, b, prec):
    return f'{a:.{prec}f}' == f'{b:.{prec}f}'

En termes d'erreur absolue, vous pouvez simplement vérifier

if abs(a - b) <= error:
    print("Almost equal")

Quelques informations sur les raisons pour lesquelles les flotteurs agissent bizarrement en Python https://youtu.be/v4HhvoNLILk?t=1129

Vous pouvez également utiliser math.isclose pour les erreurs relatives