none
Posible bug RRS feed

  • Pregunta

  • Hola,

    Escribo esto aquí porque el formulario de bugs me da problemas.

    Creo qye hay un error de cálculo en .NET, que nos ha llevado de cabeza la última semana. El código es el siguiente:

    float f1 = 0.9f / 9.0f;
    float f2 = 9f / 9.0f;
    f2 = f2 / 10f;
    float f3 = 9.0f / 90.0f;

    Como podéis ver a simple vista, el resultado de estas tres operaciones debería ser el mismo, es decir "0.1". La verdad es que no es así, siendo los resultados:
    f1 = 0.099999994
    f2 = 0.1
    f3 = 0.1

    Espero no estar haciendo nada raro, pero si en realidad es un bug, espero que el equipo de Microsoft corrija este error de manera urgente.

    - He probado a hacer el mismo ejemplo en double y en decimal, siendo el resultado idéntico.
    - He ejecutado este mismo error en diversas máquinas por si fuese un bug del microprocesador, siendo el resultado idéntico.
    - He probado a cambiar el target del framework, siendo el resultado idéntico.
    - He intentado reproducir este mismo error con otros compiladores, así como en MATLAB y Octave y no ocurre tal problema.
    - El código ha sido compilado con VS 2012, del que tenemos licencia en la empresa, aunque se ha probado con versiones trial del 2010 y 2013 y sucede exactamente lo mismo.

    Basándome en lo anterior, deduzco que existe un bug en el compilador, dado que una operación de coma flotante de estas características (IEEE 754) debería tener ancho de bits suficiente para hacer esta simple operación sin generar errores de resolución.

    Bueno, quedo a la espera del equipo de Microsoft.


    • Editado Carles F jueves, 29 de enero de 2015 13:44 error tipográfico
    jueves, 29 de enero de 2015 13:42

Todas las respuestas

  • No. No es un bug. Es el comportamiento propio del float, tal como se define en el standard ieee754. Un bug sería que un número de punto flotante de precisión sencilla que sigue el standard mencionado, diera como resultado algo diferente.

    No sé si vale la pena explicar el resultado (no te conozco y no se desde donde debería empezar la explicación). 

    Cuando operas con dos floats, y existe una diferencia en el orden de las cifras (0.9 está entre 2^(-1) y 2^0, y 9 está entre 2^3 y 2^4), y la parte fraccionaria de uno o ambos, no es potencia de 2 (0.9 no es potencia de 2), debes esperar una pérdida de precisión. Cuando vos tenés que representar una parte entera, ésta le quita espacio a la representación de la parte fraccionaria. Si la parte entera necesita 3 bits, la parte fracionaria pierde ese ancho para su representación.

    jueves, 29 de enero de 2015 14:15
  • Hola,

    Entiendo lo que quieres expresar. Pero pensaba que este tipo de operaciones en un compilador sería más "user friendly".

    No entiendo muy bien porqué esto no sucede en el resto de compiladores. Sinceramente, que el usuario tenga que pensar en formato máquina es como volver al ensamblador, así que supongo que el resto de compiladores trabajan a un nivel más alto o están mucho más evolucionados.

    ¿Hay alguna solución a esto? ¿Se puede cambiar el formato de representación de coma flotante?

    Saludos y gracias

    jueves, 29 de enero de 2015 15:13