¿Cuál es la mejor manera de comparar carrozas para casi igualdad en Python?

Es bien sabido que comparar flotadores por igualdad es un poco complicado debido a problemas de redondeo y precisión.

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

¿Cuál es la forma recomendada de lidiar con esto en Python?

¿Seguramente hay una función de biblioteca estándar para esto en alguna parte?

Python 3.5 agrega las funciones math.iscloseycmath.isclose como se describe en PEP 485 .

Si está utilizando una versión anterior de Python, la función equivalente se proporciona en la documentación .

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_toles una tolerancia relativa, se multiplica por la mayor de las magnitudes de los dos argumentos; A medida que los valores se hacen más grandes, también lo hace la diferencia permitida entre ellos mientras los consideramos iguales.

abs_toles una tolerancia absoluta que se aplica tal cual en todos los casos. Si la diferencia es menor que cualquiera de esas tolerancias, los valores se consideran iguales.

¿Algo tan simple como lo siguiente no es lo suficientemente bueno?

return abs(f1 - f2) <= allowed_error

Estoy de acuerdo en que la respuesta de Gareth es probablemente la más adecuada como una función / solución ligera.

Pero pensé que sería útil tener en cuenta que si está utilizando NumPy o lo está considerando, hay una función empaquetada para esto.

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

Sin embargo, un pequeño descargo de responsabilidad: instalar NumPy puede ser una experiencia no trivial dependiendo de su plataforma.

Utilice el decimalmódulo de Python , que proporciona la Decimalclase.

De los comentarios:

Vale la pena señalar que si está haciendo un trabajo matemático pesado y no necesita absolutamente la precisión del decimal, esto realmente puede empantanar las cosas. Los flotadores son mucho más rápidos de tratar, pero imprecisos. Los decimales son extremadamente precisos pero lentos.

No conozco nada en la biblioteca estándar de Python (o en otro lugar) que implemente la AlmostEqual2sComplementfunción de Dawson . Si ese es el tipo de comportamiento que desea, deberá implementarlo usted mismo. (En ese caso, en lugar de usar los inteligentes trucos bit a bit de Dawson, probablemente harías mejor en usar pruebas más convencionales de la forma if abs(a-b) <= eps1*(abs(a)+abs(b)) + eps2o similares. Para obtener un comportamiento similar a Dawson, podrías decir algo así como if abs(a-b) <= eps*max(EPS,abs(a),abs(b))para algunos pequeños arreglados EPS; esto no es exactamente lo mismo que Dawson, pero es similar en espíritu.

La sabiduría común de que los números de coma flotante no se pueden comparar para la igualdad es inexacta. Los números de coma flotante no son diferentes de los enteros: si evalúa "a == b", obtendrá verdadero si son números idénticos y falso de lo contrario (entendiendo que dos NaNs no son números idénticos).

El problema real es este: si he hecho algunos cálculos y no estoy seguro de que los dos números que tengo que comparar son exactamente correctos, ¿entonces qué? Este problema es el mismo para el punto flotante que para los enteros. Si evalúa la expresión entera "7/3 * 3", no se comparará igual a "7 * 3/3".

Supongamos que preguntamos "¿Cómo comparo enteros para la igualdad?" en tal situación. No hay una única respuesta; lo que debe hacer depende de la situación específica, en particular qué tipo de errores tiene y qué desea lograr.

Aquí hay algunas opciones posibles.

Si desea obtener un resultado "verdadero" si los números matemáticamente exactos fueran iguales, entonces podría intentar usar las propiedades de los cálculos que realiza para demostrar que obtiene los mismos errores en los dos números. Si eso es factible, y compara dos números que resultan de expresiones que darían números iguales si se calculan exactamente, entonces obtendrá "verdadero" de la comparación. Otro enfoque es que podría analizar las propiedades de los cálculos y demostrar que el error nunca excede una cierta cantidad, tal vez una cantidad absoluta o una cantidad relativa a una de las entradas o una de las salidas. En ese caso, puede preguntar si los dos números calculados difieren en esa cantidad como máximo y devolver "verdadero" si están dentro del intervalo. Si no puede probar un error vinculado, puedes adivinar y esperar lo mejor. Una forma de adivinar es evaluar muchas muestras aleatorias y ver qué tipo de distribución se obtiene en los resultados.

Por supuesto, dado que solo establecemos el requisito de que sea "verdadero" si los resultados matemáticamente exactos son iguales, dejamos abierta la posibilidad de que sea "verdadero" incluso si son desiguales. (De hecho, podemos satisfacer el requisito siempre devolviendo "verdadero". Esto hace que el cálculo sea simple pero generalmente no es deseable, por lo que discutiremos la mejora de la situación a continuación).

Si desea obtener un resultado "falso" si los números matemáticamente exactos fueran desiguales, debe probar que su evaluación de los números arroja números diferentes si los números matemáticamente exactos fueran desiguales. Esto puede ser imposible para fines prácticos en muchas situaciones comunes. Así que consideremos una alternativa.

Un requisito útil podría ser que obtengamos un resultado "falso" si los números matemáticamente exactos difieren en más de una cierta cantidad. Por ejemplo, tal vez vamos a calcular dónde viajó una pelota lanzada en un juego de computadora, y queremos saber si golpeó un bate. En este caso, ciertamente queremos ser "verdaderos" si la pelota golpea el bate, y queremos ser "falsos" si la pelota está lejos del bate, y podemos aceptar una respuesta "verdadera" incorrecta si la pelota entra una simulación matemáticamente exacta falló el bate pero está a un milímetro de golpear el bate. En ese caso, debemos demostrar (o adivinar / estimar) que nuestro cálculo de la posición de la pelota y la posición del bate tienen un error combinado de como máximo un milímetro (para todas las posiciones de interés). Esto nos permitiría volver siempre "

Entonces, cómo decide qué devolver cuando compara números de punto flotante depende mucho de su situación específica.

En cuanto a cómo probar los límites de error para los cálculos, eso puede ser un tema complicado. Cualquier implementación de punto flotante que use el estándar IEEE 754 en el modo redondeado al más cercano devuelve el número de punto flotante más cercano al resultado exacto para cualquier operación básica (en particular, multiplicación, división, suma, resta, raíz cuadrada). (En caso de empate, redondee para que el bit bajo sea par.) (Tenga especial cuidado con la raíz cuadrada y la división; su implementación de lenguaje podría usar métodos que no se ajustan a IEEE 754 para esos). Debido a este requisito, sabemos que El error en un solo resultado es como máximo la mitad del valor del bit menos significativo. (Si fuera más, el redondeo habría ido a un número diferente que está dentro de la mitad del valor).

Continuar desde allí se vuelve mucho más complicado; El siguiente paso es realizar una operación donde una de las entradas ya tiene algún error. Para expresiones simples, estos errores pueden seguirse a través de los cálculos para alcanzar un límite en el error final. En la práctica, esto solo se hace en algunas situaciones, como trabajar en una biblioteca matemática de alta calidad. Y, por supuesto, necesita un control preciso sobre exactamente qué operaciones se realizan. Los lenguajes de alto nivel a menudo le dan al compilador mucha holgura, por lo que es posible que no sepa en qué orden se realizan las operaciones.

Hay mucho más que podría (y está) escrito sobre este tema, pero tengo que parar allí. En resumen, la respuesta es: no hay una rutina de biblioteca para esta comparación porque no hay una solución única que se adapte a la mayoría de las necesidades que valga la pena poner en una rutina de biblioteca. (Si comparar con un intervalo de error relativo o absoluto es suficiente para usted, puede hacerlo simplemente sin una rutina de biblioteca).

Si desea usarlo en pruebas / contexto TDD, diría que esta es una forma estándar:

from nose.tools import assert_almost_equals

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

math.isclose () se ha agregado a Python 3.5 para eso ( código fuente ). Aquí hay un puerto para Python 2. Su diferencia con respecto a Mark Ransom es que puede manejar "inf" y "-inf" correctamente.

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

La siguiente comparación me pareció útil:

str(f1) == str(f2)

Para algunos de los casos en los que puede afectar la representación del número fuente, puede representarlos como fracciones en lugar de flotantes, utilizando un numerador y un denominador enteros. De esa manera puedes tener comparaciones exactas.

Vea la fracción del módulo de fracciones para más detalles.

Me gustó la sugerencia de @Sesquipedal pero con modificaciones (un caso de uso especial cuando ambos valores son 0 devuelve False). En mi caso, estaba en Python 2.7 y solo usé una función simple:

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

Útil para el caso en el que desea asegurarse de que 2 números sean iguales 'hasta la precisión', no es necesario especificar la tolerancia:

• Encuentra la precisión mínima de los 2 números

• Redondea ambos con una precisión mínima y compara

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)                               

Tal como está escrito, solo funciona para números sin la 'e' en su representación de cadena (es decir, 0.9999999999995e-4 <número <= 0.9999999999995e11)

Ejemplo:

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

Para comparar hasta un decimal dado sin 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 

Esto quizás sea un truco un poco feo, pero funciona bastante bien cuando no necesita más que la precisión de flotación predeterminada (aproximadamente 11 decimales).

La función round_to usa el método de formato de la clase str incorporada para redondear el flotante a una cadena que representa el flotante con el número de decimales necesarios, y luego aplica la función incorporada eval a la cadena flotante redondeada para volver al tipo numérico flotante.

La función is_close solo aplica un condicional simple al flotante redondeado.

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

Actualizar:

Según lo sugerido por @stepehjfox, una forma más limpia de construir una función rount_to evitando "eval" es usar el formato anidado :

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

Siguiendo la misma idea, el código puede ser aún más simple usando las nuevas y geniales cadenas f (Python 3.6+):

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

Entonces, incluso podríamos envolverlo todo en una función simple y limpia 'is_close' :

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

En términos de error absoluto, solo puede verificar

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

Alguna información de por qué flotador actúa raro en Python https://youtu.be/v4HhvoNLILk?t=1129

También puede usar math.isclose para errores relativos