Logaritmo inexacto en Python

Question

Trabajo a diario con Python 2.4 en mi empresa. Utilicé la función de logaritmo versátil 'log' de la biblioteca matemática estándar, y cuando ingresé el registro (2 ** 31, 2) devolvió 31.000000000000004, lo que me pareció un poco extraño.

Hice lo mismo con otras potencias de 2, y funcionó perfectamente. Ejecuté 'log10 (2 ** 31)/log10 (2)' y obtuve una ronda 31.0

Intenté ejecutar la misma función original en Python 3.0.1, suponiendo que se solucionó en una versión más avanzada.

¿Por qué sucede esto? ¿Es posible que haya algunas imprecisiones en las funciones matemáticas en Python?

Answer 1

Esto es de esperar con la aritmética de la computadora. Sigue reglas particulares, como IEEE 754, que probablemente no coincidan con las matemáticas que aprendió en la escuela.

Si esto realmente importa , utilice Python's decimal type.

Ejemplo:

from decimal import Decimal, Context 
ctx = Context(prec=20) 
two = Decimal(2) 
ctx.divide(ctx.power(two, Decimal(31)).ln(ctx), two.ln(ctx)) 

Answer 2

Siempre asumir que las operaciones de punto flotante tendrá algún error en ellos y comprobar la igualdad de tomar que el error en cuenta (ya sea un valor de porcentaje como 0,00001% o un valor fijo como ,00000000001) Esta inexactitud es un hecho ya que no todos los números decimales pueden representarse en binario con un número fijo de bits de precisión.

Su caso particular no es uno de ellos si Python usa IEEE754 ya que 31 debería ser fácilmente representable con una sola precisión. Sin embargo, es posible que pierda precisión en uno de los muchos pasos necesarios para calcular el registro , simplemente porque no tiene código para detectar casos especiales como una potencia directa de dos.

Answer 3

operaciones de punto flotante nunca son exactas. Devuelven un resultado que tiene un error relativo aceptable para la infraestructura de idioma/hardware.

En general, es un error suponer que las operaciones de coma flotante son precisas, especialmente con precisión simple. "Accuracy problems" section de Wikipedia Artículo de punto flotante :)

Answer 4

Esto es normal. Esperaría que log10 sea más preciso que log (x, y), ya que sabe exactamente cuál es la base del logaritmo, también puede haber algo de soporte de hardware para calcular los logaritmos de base 10.

Answer 5

Debe leer "Lo que todo científico informático debe saber sobre la aritmética de coma flotante".

http://docs.sun.com/source/806-3568/ncg_goldberg.html

Answer 6

números de punto flotante IEEE dobles tienen 52 bits of precision. Desde 10^15 < 2^52 < 10^16, un doble tiene entre 15 y 16 cifras significativas. El resultado 31.000000000000004 es correcto a 16 cifras, por lo que es tan bueno como puede esperar.

Answer 7

El repr esentation (float.__repr__) de un número en pitón trata de devolver una cadena de dígitos como cerca del valor real como sea posible cuando se convierte de nuevo, dado que IEEE-754 aritmética es preciso hasta un límite.En cualquier caso, si el resultado print Ed, usted no notará:

>>> from math import log 
>>> log(2**31,2) 
31.000000000000004 
>>> print log(2**31,2) 
31.0 

print convierte sus argumentos para cuerdas (en este caso, a través del método float.__str__), que atiende a la inexactitud exhibiendo menos dígitos :

>>> log(1000000,2) 
19.931568569324174 
>>> print log(1000000,2) 
19.9315685693 
>>> 1.0/10 
0.10000000000000001 
>>> print 1.0/10 
0.1 

usuallyuseless respuesta es muy útil, en realidad :)