Visual Studio 2010 que muestra un comportamiento extraño en flotación/incremento doble [duplicado]

Posible duplicado:
Manejo de problemas de precisión en números de punto flotante

Estoy escribiendo una animación OpenGl y estoy usando una variable flotante "tiempo" para realizar un seguimiento del tiempo. Estoy incrementando la variable "tiempo" en 0.01. Tengo ciertas condiciones que cumplir cada vez que "tiempo" alcanza un valor entero. El problema es que después de cierto tiempo, el incremento flotante muestra un comportamiento extraño. Empiezo desde time = 0 y veo que después de que "time" llega a 0.83, el siguiente valor es 0.839999. Pensé que esto podría estar relacionado con la precisión flotante, así que intenté usar double/long double y descubrí que, en lugar de alcanzar el valor 1.00, el código alcanza el valor 1.0000007.

Intenté incrementar por "0.01f" en lugar de "0.01" pero no tuve éxito. ¿Es esto un error en Visual Studio o lo estoy haciendo de manera incorrecta? Podría publicar el código, pero no creo que sea de mucha utilidad, ya que estoy asignando "tiempo" solo en un lugar y solo se está usando en otros lugares.

preguntado el 04 de diciembre de 12 a las 04:12

No es un error en el compilador. De hecho, cada vez que observe algún comportamiento extraño en su programa y se le ocurra pensar: "Me pregunto si se trata de un error en el compilador", puede estar seguro de que la respuesta es nunca (casi nunca). no importa) "sí" Aceptar esto te hará un programador más feliz y productivo. -

3 Respuestas

Nunca compare valores de punto flotante para la igualdad a menos que sepa exactamente qué estás haciendo. Le sugiero enfáticamente que use números enteros (quizás números enteros de milisegundos) para este propósito.

Ver Lo que todo informático debe saber sobre la aritmética de coma flotante para obtener más información.

El punto flotante es un formato de precisión fija. Esta es una limitación inherente de los formatos de precisión fija.

Por ejemplo, digamos que usó seis dígitos decimales de precisión. un tercio seria .333333. Pero si sumas un tercio tres veces, obtienes .999999, no 1. Esa es la naturaleza de la bestia.

Respondido el 04 de diciembre de 12 a las 04:12

No es exactamente recomendar esto, pero el problema es que el 0.1 no se puede representar exactamente como el doble. 1.0 puede ser. Entonces, si hace que su paso de tiempo sea una potencia (negativa) de dos, encontrará una diferencia. A modo de ilustración:

    double delta = 1.0 / 8;
    int stopper = 10;
    int nextInt = 1;
    for (double t = 0; t <= stopper; t += delta)
    {
        if (t == nextInt)
        {
            std::cout << "int ";
            ++nextInt;
        }
        else 
            std::cout << "    ";
        std::cout << t << std::endl;
    }

Respondido el 04 de diciembre de 12 a las 04:12

Simplemente redondee el "tiempo" después de cada incremento para asegurarse de que mantenga un valor razonable.

Algo como eso:

double round(double value, double precision)
{
    return floor(value / precision + 0.5) * precision;
}
time = round(time + 0.1, 0.1);

Respondido el 04 de diciembre de 12 a las 04:12

No es la respuesta que estás buscando? Examinar otras preguntas etiquetadas or haz tu propia pregunta.