¿Hay una solución para la coma flotante problemas aritméticos en C ++?

Question

Me estoy haciendo un poco de aritmética de punto flotante y tener problemas de precisión. El valor resultante es diferente en dos máquinas para la misma entrada. He leído el mensaje @ Por qué no puedo multiplicar un flotador? y también leer otro material en la web y entiende que se tiene que ver con la representación binaria de punto flotante y en la máquina épsilon. Sin embargo, quería comprobar si hay una manera de resolver este problema / Algunos torno al trabajo de la aritmética de punto flotante en C ++ ?? Estoy convirtiendo un flotador a corto sin signo para el almacenamiento y estoy convirtiendo vuelta cuando sea necesario. Sin embargo, al convertir de nuevo a corto sin signo, la precisión (6 puntos decimales) sigue siendo correcta en un equipo pero no en el otro.

//convert FLOAT to short

unsigned short sConst = 0xFFFF;

unsigned short shortValue = (unsigned short)(floatValue * sConst);

//Convert SHORT to FLOAT

float floatValue = ((float)shortValue / sConst);

Answer 1

A short debe ser de al menos 16 bits, y en una gran cantidad de implementaciones que es exactamente lo que es. Un unsigned 16 bits short sostendrá valores de 0 a 65535. Esto significa que un corto no dará un total de cinco dígitos de precisión, y, ciertamente, no seis. Si quieres seis dígitos, que necesita 20 bits.

Por lo tanto, cualquier pérdida de precisión se debe probablemente al hecho de que usted está tratando de paquete de seis dígitos de precisión en algo menos de cinco dígitos. No hay una solución para esto, aparte de usar un tipo entero que probablemente tiene tanto de almacenamiento como un float.

No sé por qué se parecería a trabajar en un sistema dado. Estaba usando los mismos números en ambos? ¿Uno utiliza un sistema de punto flotante de más edad, y uno que casualmente dio los resultados que usted esperaba en las muestras que ha intentado? ¿Era posiblemente utilizando un short grande que el otro?

Answer 2

Si desea utilizar tipos de coma flotante nativos, lo mejor que puede hacer es afirmar que los valores emitidos por el programa no difieren demasiado de un conjunto de valores de referencia.

La definición precisa de "demasiado" depende totalmente de su aplicación. Por ejemplo, si usted calcula a + b en diferentes plataformas, debe encontrar los dos resultados estén dentro precisión de la máquina de la otra. Por otro lado, si estás haciendo algo más complicado como inversión de la matriz, los resultados serán muy probablemente diferir en más de precisión de la máquina. Determinar con precisión qué tan cerca se puede esperar que los resultados sean el uno al otro es un proceso muy sutil y complicado. A menos que sepa exactamente lo que está haciendo, es probable que sea más seguro (y más sano) para determinar la cantidad de precisión que necesita aguas abajo en la aplicación y verificar que el resultado sea lo suficientemente precisa.

Para obtener una idea acerca de cómo calcular el error relativo entre dos valores de coma flotante con firmeza, ver esta respuesta y la guía de coma flotante vinculado en él:

flotante funciones de comparación de puntos para C #

Answer 3

¿Usted está buscando para el estándar de la siguiente manera:

Lenguajes de programación C ++ - Informe Técnico de Tipo 2 de extensiones para el lenguaje de programación C ++ para soporte flotante decimal punto de proyecto aritmética

Answer 4

En lugar de utilizar 0xFFFF uso medio de ella, es decir, 32 768 para la conversión. 32768 (Ox8000) tiene una representación binaria de 1000000000000000 mientras que OxFFFF tiene una representación binaria de la representación binaria 1111111111111111. Ox8000 's implica claramente, las operaciones de multiplicación y Divsion durante la conversión (a corto (o) mientras que la conversión de nuevo a float) no valores de precisión de cambio después de cero. Para una conversión lado, sin embargo OxFFFF es preferible, ya que conduce a resultado más exacto.