flotante de impresión, preservando la precisión

Question

Estoy escribiendo un programa que imprime literales de punto flotante para ser utilizado dentro de otro programa.

¿Cuántos dígitos necesito imprimir para preservar la precisión del flotador original?

Dado que un flotador tiene 24 * (log(2)/log(10)) = 7.2247199 dígitos decimales de precisión, mi idea inicial fue que la impresión de 8 dígitos debería ser suficiente. Pero si no tengo suerte, esos 0.2247199 se distribuyen a la izquierda y a la derecha de los 7 dígitos significativos, por lo que probablemente debería imprimir 9 dígitos decimales.

¿Mi análisis es correcto? ¿Son suficientes 9 decimales para todos los casos? Me gusta printf("%.9g", x);?

¿Hay una función estándar que convierta un flotador en una cadena con el número mínimo de dígitos decimales requerido para ese valor, en el caso de que 7 u 8 sean suficientes, así que no imprimo dígitos innecesarios?

Nota: No puedo usar literales de coma flotante hexadecimales, porque C++ estándar no los admite.

Answer 1

Con el fin de garantizar que un binary-> decimal-> ida y vuelta binaria recupera el valor binario original, IEEE 754 requiere

The original binary value will be preserved by converting to decimal and back again using:[10] 

    5 decimal digits for binary16 
    9 decimal digits for binary32 
    17 decimal digits for binary64 
    36 decimal digits for binary128 

For other binary formats the required number of decimal digits is 

    1 + ceiling(p*log10(2)) 

where p is the number of significant bits in the binary format, e.g. 24 bits for binary32. 

En C, las funciones que pueden utilizarse para estas conversiones son snprintf() y strtof/strtod/strtold().

Por supuesto, en algunos casos, incluso más dígitos pueden ser útiles (no, no siempre son "ruidosos", dependiendo de la implementación de las rutinas de conversión decimal como snprintf()). Considere, por ejemplo, printing dyadic fractions.

Answer 2

Se garantiza que la conversión de coma flotante a decimal utilizada en Java produce el menor número de dígitos decimales más allá del punto decimal necesario para distinguir el número de sus vecinos (más o menos).

Puede copiar el algoritmo de aquí: http://www.docjar.com/html/api/sun/misc/FloatingDecimal.java.html atención atención a la FloatingDecimal(float) constructor y el método toJavaFormatString().

Answer 3

Puede usar sprintf. No estoy seguro de si esto responde a su pregunta exactamente embargo, pero de todos modos, aquí está el código de ejemplo

#include <stdio.h> 
int main(void) 
{ 
float d_n = 123.45; 
char s_cp[13] = { '\0' }; 
char s_cnp[4] = { '\0' }; 
/* 
* with sprintf you need to make sure there's enough space 
* declared in the array 
*/ 
sprintf(s_cp, "%.2f", d_n); 
printf("%s\n", s_cp); 
/* 
* snprinft allows to control how much is read into array. 
* it might have portable issues if you are not using C99 
*/ 
snprintf(s_cnp, sizeof s_cnp - 1 , "%f", d_n); 
printf("%s\n", s_cnp); 
getchar(); 
return 0; 
} 
/* output : 
* 123.45 
* 123 
*/ 

Answer 4

24 * (log (2)/log (10)) = 7,2247199

Eso es bastante representativo para el problema. No tiene sentido expresar la cantidad de dígitos significativos con una precisión de 0.0000001 dígitos. Está convirtiendo números en texto para el beneficio de humano, no en una máquina. Un ser humano no le importa, y preferiría mucho más, si usted escribió

24 * (log (2)/log (10)) = 7

Tratando de mostrar 8 dígitos significativos sólo genera dígitos de ruido aleatorio. Con probabilidades distintas de cero, 7 ya es demasiado porque el error de coma flotante se acumula en los cálculos. Sobre todo, imprima números usando una unidad de medida razonable. La gente está interesada en milímetros, gramos, libras, pulgadas, etcétera. A ningún arquitecto le importará el tamaño de una ventana expresada con más precisión que 1 mm. Ninguna planta de fabricación de ventanas hará promesa una ventana del tamaño tan preciso como eso.

Por último, no puede ignorar la precisión de los números que introduce en su programa. No es posible medir la velocidad de un trago europeo sin carga de hasta 7 dígitos. Es aproximadamente 11 metros por segundo, 2 dígitos en el mejor de los casos. Así que realizar cálculos a esa velocidad e imprimir un resultado que tenga más dígitos significativos produce resultados sin sentido que prometen precisión que no están ahí.

Answer 5

Con algo así como

def f(a): 
    b=0 
    while a != int(a): a*=2; b+=1 
    return a, b 

(que es Python) que debe ser capaz de obtener mantisa y exponente de una manera libre de pérdidas.

En C, esto probablemente sería

struct float_decomp { 
    float mantissa; 
    int exponent; 
} 

struct float_decomp decomp(float x) 
{ 
    struct float_decomp ret = { .mantissa = x, .exponent = 0}; 
    while x != floor(x) { 
     ret.mantissa *= 2; 
     ret.exponent += 1; 
    } 
    return ret; 
} 

Pero tenga en cuenta que todavía no todos los valores pueden ser representados de esta manera, es sólo un tiro rápido que debe dar la idea, pero probablemente necesita una mejora.

Answer 6

Si el programa está destinado a ser leído por una computadora, haría el truco simple de usar char* aliasing.

• alias float*-char*
• copia en un unsigned (o cualquier tipo sin signo es suficientemente grande) a través de char* aliasing
• imprimir el valor unsigned

La descodificación se acaba de invertir el proceso (y en la mayoría de las plataformas se puede usar un reinterpret_cast directo).

Answer 7

Si tiene una biblioteca C que se ajusta a C99 (y si sus tipos flotantes tienen una base que es una potencia de 2 :) el printf carácter de formato %a puede imprimir valores de coma flotante sin falta de precisión en forma hexadecimal, y las utilidades como scanf y strod podrán leerlas.

Answer 8

Si lee estos documentos (ver a continuación), encontrará que hay algunos algoritmos que imprimen el número mínimo de dígitos decimales de manera que el número puede ser reinterpretado sin cambios (es decir, mediante scanf).

Como puede haber varios de estos números, el algoritmo también escoge la fracción decimal más cercana a la fracción binaria original (nombré el valor de flotación).

Una pena que no hay tal biblioteca estándar en C.

• http://www.cs.indiana.edu/~burger/FP-Printing-PLDI96.pdf
• http://grouper.ieee.org/groups/754/email/pdfq3pavhBfih.pdf