c++ - fmod - conversión de doble a unsigned int

math h c++ function

Question

Estoy enfrentando un problema con la conversión de valor de Doble a int. Intento ejecutar el siguiente código:

int main()
{
    double val_d= 6.25e-05;
    cout << (1/val_d) << endl;
    unsigned int val_ui = (unsigned int ) (1/val_d);
    cout << val_ui << endl;
}

la conversión de doble a int puede eliminar la parte decimal, pero la parte entera debe permanecer como está?

La salida que recibo es: 16000 15999

Entonces, ¿por qué el o / p es diferente aquí? Esto está sucediendo solo en fedora. En Windows y Ubuntu funciona bien. (Ambos resultados son 16000)

Ajusté el código anterior y obtuve los siguientes resultados:

int main()
{
  double val_d= 6.25e-05;
  cout << (1/val_d) << endl;
  double val_intermediate =  (1/val_d) ;
  cout << val_intermediate << endl;
  unsigned int val_ui = (unsigned int ) val_intermediate;
  cout << val_ui << endl;

}

NUEVA SALIDA es 16000 16000 16000

Answer 1

Cuando el texto fuente "6.25e-05" se interpreta como un número decimal y se convierte a doble, no es exactamente representable, porque los valores de punto flotante tienen una precisión limitada, y cada bit tiene un valor que es una potencia de dos, no un dígito decimal. El valor de doble precisión IEEE 754 que está más cerca de 6.25e-5 es 6.25000000000000013010426069826053208089433610439300537109375e-05 o, en punto flotante hexadecimal, 0x1.0624dd2f1a9fcp-14.

Cuando se toma el recíproco de esto, el resultado matemático exacto nuevamente no es exactamente representable, por lo que debe redondearse de nuevo. El valor de precisión doble más cercano es 16000 o 0x1.f4p + 13.

El estándar C ++ permite que las implementaciones evalúen expresiones de coma flotante con más precisión de la requerida por el tipo nominal. Algunas implementaciones usan una precisión extendida, notablemente el tipo de coma flotante de 80 bits de Intel, que tiene un significado de 64 bits. (La precisión doble regular tiene un significado de 53 bits). Con esta precisión extendida, el recíproco es 0xf.9fffffffffffe89p + 10 o 15999.99999999999966693309261245303787291049957275390625.

Obviamente, cuando el resultado de precisión extendida se trunca en un entero, el resultado es 15999.

Redondear el resultado doble-largo al doble produciría 16000. (Puede hacer esto con un molde explícito para duplicar, no necesita asignar el valor intermedio a un objeto doble).

Answer 2

La conversión de un valor de coma flotante a un valor integral elimina la parte fraccionaria, siempre que el resultado se pueda representar en el tipo integral (es decir, el valor no es demasiado grande para caber). Insertar en una secuencia redondea el valor, lo que puede producir un resultado diferente.

Answer 3

diferencia en el redondeo .

1. (1 / val_d) - el doble se redondea al número posible más cercano que se puede representar con doble precisión; (ej .: 3.6999999999999999 == 3.7)
2. (unsigned int) (1 / val_d) - cuando se convierte en fundido a la parte decimal decimal se trunca, que resulta en el redondeo hacia abajo (ej .: int (3.6) == 3