comparaison approximative en python

Question

Je veux faire « == » comparaison de l'utilisation de l'opérateur approximatif dans mon programme: valeurs à virgule flottante x et y sont égaux (==) si

abs(x-y)/(0.5(x+y)) < 0.001 

Ce qui est une bonne façon de le faire? Étant donné que float est un type intégré, je ne pense pas que je puisse redéfinir l'opérateur ==, n'est-ce pas?

Notez que je voudrais utiliser d'autres fonctionnalités de float, la seule chose que je voudrais changer est l'opérateur d'égalité.

EDIT:

Merci pour les réponses, et je comprends vos arguments sur la lisibilité et d'autres questions. Cela dit, je préférerais, si possible, continuer à utiliser le type float normal, au lieu d'avoir une nouvelle classe ou une nouvelle fonction de comparaison. Est-il même possible de redéfinir == opérateur pour les flotteurs réguliers?

Mes raisons sont ::

(a) tout le monde en utilisant le programme que je vous écris veut que les flotteurs à comparer cette façon

(b) il n'y a aucun moyen dans le anyone monde voudrait jamais utiliser le défaut == pour les flotteurs .. Pourquoi est-ce même dans la langue ???

(c) Je n'aime pas les mots supplémentaires dans le code; en utilisant évidemment les résultats float existants dans aucun changement dans le code que ce soit

EDIT 2.

Maintenant que je sais que je ne peux pas surcharger l'opérateur == pour flotteur, je dois changer ma question. Il deviendra si différent que je vais faire un nouveau à custom comparison for built-in containers

Answer 1

Votre définition a deux problèmes:

1. manque un *

2. va tenter de diviser par zéro si x + y == 0.0 (qui couvre un cas éventuellement fréquent x == y == 0.0)

Try ceci à la place:

define approx_Equal(x, y, tolerance=0.001): 
    return abs(x-y) <= 0.5 * tolerance * (x + y) 

Édition: Notez l'utilisation de <= au lieu de < ... nécessaire pour que le boîtier x == y == 0.0 fonctionne correctement.

Je ne voudrais pas essayer de passer outre ==

Edit 2: Vous avez écrit:

il n'y a aucun moyen dans le monde quelqu'un voudrait jamais utiliser la valeur par défaut == pour les flotteurs .. Pourquoi est-ce même dans la langue ???

Pas moyen? Supposons que vous ayez une fonction qui renvoie un flottant, et que vous ayez un brainwave sur un algorithme qui produirait les mêmes réponses plus rapidement et/ou plus élégamment; comment le testez-vous?

Answer 2

Si vous enveloppez les nombres dans une classe, vous pouvez surcharger « == » avec:

def __eq__(self, x): 
    return abs(x - self.x)/(0.5 * (x + self.x)) < 0.001 

mais vous devez réécrire l'expression

abs(x - self.x) < 0.0005 * (x + self.x)

pour éviter la division zéro.

Answer 3

Vous pouvez créer une nouvelle classe dérivant du type de flotteur intégré, puis remplacer les opérateurs nécessaires:

class InexactFloat(float): 
    def __eq__(self, other): 
     try: 
      return abs(self.real - other)/(0.5 * (abs(self.real) + abs(other))) < 0.001 
     except ZeroDivisionError: 
      # Could do another inexact comparison here, this is just an example: 
      return self.real == other 

    def __ne__(self, other): 
     return not self.__eq__(other) 

print 5.2 == 5.20000000000001 # False 
print 5.2 != 5.20000000000001 # True 
print InexactFloat(5.2) == InexactFloat(5.20000000000001) # True 
print InexactFloat(5.2) != InexactFloat(5.20000000000001) # False 
print InexactFloat(-5) == -5 # True 

# Works for InexactFloat <-> float comparison 
print 5.0 == InexactFloat(5.0) # True 
print InexactFloat(5.0) == 5.0 # True 

# Zero division case (note how I implemented it above!) 
print InexactFloat(-0.00001) == InexactFloat(0.00001) # False 
print InexactFloat(-0.000000001) == InexactFloat(0.000000001) # False 
print InexactFloat(-5) == InexactFloat(5) # False 

# Unit test for fixed negative numbers problem 
print InexactFloat(-5) == InexactFloat(-10) # False 

Vous pouvez également remplacer les opérateurs comme < = etc.