floating point - que - PI y precisión de un número de coma flotante

punto flotante normalizado

Question

Una representación de punto flotante de precisión simple / doble / extendida de Pi es precisa hasta cuántos lugares decimales?

Answer 1

Dado que hay ecuaciones de criba para representaciones binarias de pi, se podrían combinar variables para almacenar fragmentos del valor para aumentar la precisión. La única limitación a la precisión en este método es la conversión de binario a decimal, pero incluso los números racionales pueden tener problemas con eso.

Answer 2

En la unidad de punto flotante x86 (x87), hay instrucciones para cargar ciertas constantes de coma flotante. "fldz" y "fld1" cargan 0.0 y 1.0 en el st superior de la pila (o st (0)) por ejemplo. Otro es "fldpi". Todos estos valores tienen una mantisa de 64 bits de largo que se traduce en cerca de 20 dígitos decimales. Los 64 bits son posibles a través del formato de punto flotante tempreal de 80 bits utilizado internamente en el x87. El x87 también puede cargar tempreals y almacenarlos en ubicaciones de memoria de 10 bytes.

Answer 3

6 lugares y 14 lugares.1 lugar es más de 0 para el 3, y el último lugar aunque almacenado no se puede considerar como un punto de precisión.

Y lo siento, pero no sé lo que significa sin más contexto. ¿Te refieres al decimal de C #?

Answer 4

Imprime y cuenta, bebé, imprime y cuenta. (O lee las especificaciones )

Answer 5

World of PI tiene PI en 100,000,000,000 de dígitos, puede imprimir y comparar. Para una versión un poco más fácil de leer Joy of PI tiene 10,000 dígitos. Y si quiere recordar los dígitos usted mismo, podría intentar escribir el poema de Cadenza Cadaeic .

Answer 6

Para el código C, mire las definiciones en <float.h> . Eso cubre las FLT_* float ( FLT_* ), double ( DBL_* ) y long double ( LDBL_* ).

Answer 7

Cuando examiné la respuesta de Quassnoi, me pareció sospechoso que el doble y el doble largos terminarían con la misma precisión, así que profundicé un poco. Si ejecuté su código compilado con clang obtuve los mismos resultados que él, sin embargo, encontré que si especificaba el sufijo doble largo y usaba un literal para inicializar el doble largo, proporcionaba más precisión. Aquí está mi versión de su código:

#include <stdio.h>

int main(int argc, char** argv)
{
    long double pild = 3.14159265358979323846264338327950288419716939937510582097494459230781640628620899L;
    double pid = pild;
    float pif = pid;
    printf("%s/n%1.80f/n%1.80f/n%1.80Lf/n",
        "3.14159265358979323846264338327950288419716939937510582097494459230781640628620899",
        pif, pid, pild);
    return 0;
}

Y los resultados:

3.14159265358979323846264338327950288419716939937510582097494459230781640628620899

3.14159274101257324218750000000000000000000000000000000000000000000000000000000000
        ^
3.14159265358979311599796346854418516159057617187500000000000000000000000000000000
                 ^
3.14159265358979323851280895940618620443274267017841339111328125000000000000000000
                    ^

Answer 8

las nuevas funciones math.h __sinpi () y __cospi () arreglaron el problema para ángulos rectos como 90 grados y tal.

    cos(M_PI * -90.0 / 180.0) returns 0.00000000000000006123233995736766
__cospi( -90.0 / 180.0 )      returns 0.0, as it should

/*  __sinpi(x) returns the sine of pi times x; __cospi(x) and __tanpi(x) return
the cosine and tangent, respectively.  These functions can produce a more
accurate answer than expressions of the form sin(M_PI * x) because they
avoid any loss of precision that results from rounding the result of the
multiplication M_PI * x.  They may also be significantly more efficient in
some cases because the argument reduction for these functions is easier
to compute.  Consult the man pages for edge case details.                 */
extern float __cospif(float) __OSX_AVAILABLE_STARTING(__MAC_10_9, __IPHONE_NA);
extern double __cospi(double) __OSX_AVAILABLE_STARTING(__MAC_10_9, __IPHONE_NA);
extern float __sinpif(float) __OSX_AVAILABLE_STARTING(__MAC_10_9, __IPHONE_NA);
extern double __sinpi(double) __OSX_AVAILABLE_STARTING(__MAC_10_9, __IPHONE_NA);
extern float __tanpif(float) __OSX_AVAILABLE_STARTING(__MAC_10_9, __IPHONE_NA);
extern double __tanpi(double) __OSX_AVAILABLE_STARTING(__MAC_10_9, __IPHONE_NA);

Answer 9

La precisión de un tipo de punto flotante no está relacionada con PI ni con ningún número específico . Solo depende de cuántos dígitos se almacenan en la memoria .

En el caso del float IEEE-754 usa 23 bits de mantisa para que pueda tener una precisión de 23 + 1 bits de precisión, o ~ 7 dígitos de precisión en decimales. Del mismo modo, el double (53 bit de mantisa) puede almacenar 15 ~ 17 dígitos decimales de precisión

Answer 10

#include <stdio.h>

#define E_PI 3.1415926535897932384626433832795028841971693993751058209749445923078164062

int main(int argc, char** argv)
{
    long double pild = E_PI;
    double pid = pild;
    float pif = pid;
    printf("%s/n%1.80f/n%1.80f/n%1.80Lf/n",
    "3.14159265358979323846264338327950288419716939937510582097494459230781640628620899",
    pif, pid, pild);
    return 0;
}

Resultados:

[quassnoi #] gcc --version
gcc (GCC) 4.3.2 20081105 (Red Hat 4.3.2-7)

[quassnoi #] ./test

3.14159265358979323846264338327950288419716939937510582097494459230781640628620899

3.14159274101257324218750000000000000000000000000000000000000000000000000000000000
        ^
3.14159265358979311599796346854418516159057617187500000000000000000000000000000000
                 ^
3.14159265358979311599796346854418516159057617187500000000000000000000000000000000
                 ^
  0000000001111111
  1234567890123456