Comparando float y double en C

⏰ 3 minutos de lectura

Rijul Ganguly

Escribí el siguiente código para comparar entre una variable flotante y una variable doble en C.

int main()
{
    float f = 1.1;
    double d = 1.1;

    if(f==d)
        printf("EQUAL");

    if(f < d)
        printf("LESS");

    if(f > d)
        printf("GREATER");

    return 0;
}

Estoy usando un compilador de C en línea aquí para compilar mi código.

Sé que EQUAL nunca se imprimirá para decimales periódicos. Sin embargo, lo que espero que se imprima es MENOS, ya que el doble debe tener una mayor precisión y, por lo tanto, debe estar más cerca del valor real de 1.1 que el valor flotante. Hasta donde yo sé, en C, cuando comparas float y double, la mantisa del float se extiende de cero a doble, y ese valor de cero extendido siempre debe ser menor.

En cambio, en todas las situaciones se está imprimiendo MAYOR. ¿Me estoy perdiendo de algo?

tal vez puede ser: float -> 1.09999999999 y double ->1.1 … float no redondea siempre a un valor más alto, pero el cierre es representable

–Alberto Sinigaglia

30 de noviembre de 2019 a las 12:00
Si el valor redondeado ya es mayor, puede agregar tantos ceros como desee. No se hará más pequeño.

– Gerhardh

30 de noviembre de 2019 a las 13:12
π con cinco dígitos decimales es 3.1416. π a diez dígitos decimales es 3.141592654. Entonces, π de cinco dígitos es mayor que π de diez dígitos. Cuando un número decimal en el código fuente se convierte a float o doubleestá redondeado al valor representable más cercano, no truncado. (Al menos por lo general; puede haber excepciones según los estándares del idioma, la calidad de la implementación, etc.)

–Eric Postpischil

30 de noviembre de 2019 a las 14:07
@EricPostpischil Sí, ahí es donde cometí el error, pensé que los valores flotantes estaban truncados en lugar de redondeados. Gracias por tu respuesta 🙂

– Rijul Ganguly

30 de noviembre de 2019 a las 18:53
con respecto a: float f = 1.1; esto es tratar de exprimir un double literal en un float variable. Mucho mejor usar: float f = 1.1f; Tenga en cuenta el final f que convierte lo literal en float valor

– usuario3629249

3 de diciembre de 2019 a las 1:42

El valor exacto del flotante más cercano a 1.1 es 1.10000002384185791015625. El equivalente binario es 1.00011001100110011001101

El valor exacto del doble más cercano a 1.1 es 1.100000000000000088817841970012523233890533447265625. El equivalente binario es 1.0001100110011001100110011001100110011001100110011010.

Alineando los dos números binarios uno al lado del otro:

1.00011001100110011001101
1.0001100110011001100110011001100110011001100110011010

Los primeros bits truncados para el redondeo a flotante son 11001100, que es mayor que la mitad, por lo que la conversión a flotante se redondeó hacia arriba, lo que hace que sus bits menos significativos sean 11001101. Ese redondeo resultó en que la diferencia más significativa fue un 1 en el flotante en un bit posición que es 0 en el doble. El flotante es mayor que el doble, independientemente de que los valores de los bits de menor importancia sean cero en el flotante extendido a doble, pero distintos de cero en el doble.

Si agrega las siguientes 2 líneas después de declarar las 2 variables:

printf("%.9g\n", f);
printf("%.17g\n", d);

obtendrá el siguiente resultado:

1.10000002                                                                                                                  
1.1000000000000001

así que es fácil ver que debido a precisión los float es mayor que el double así la impresión de GREATER está bien.

Sí, de hecho tienes razón aquí. Pero pensé que la mantisa del flotador siempre se extendía a cero para doblar cuando se comparaba con un doble. ¿No es así como funciona?

– Rijul Ganguly

30 de noviembre de 2019 a las 12:14
@RijulGanguly Bueno, si tomas 1.10000002 y lo extiendes a cero, obtienes 1.1000000200000000, que sigue siendo mayor que 1.1000000000000001, ¿verdad? (¿O me estoy perdiendo algo?)

– Steve cumbre

30 de noviembre de 2019 a las 12:23
@SteveSummit exactamente, esto es bastante sencillo en ese sentido

– David

30 de noviembre de 2019 a las 12:24
“debido a la precisión, el flotador es mayor que el doble” induce a error un poco. Debido a la diferente precisión, los valores difieren. En este caso, el float fue mayor Alrededor de la mitad de todos los no exactos decimaleslos double será mayor.

– chux – Reincorporar a Monica

30 de noviembre de 2019 a las 17:29

¿Ha sido útil esta solución?

Tu feedback nos ayuda a saber si la solución es correcta y está funcionando. De esta manera podemos revisar y corregir el contenido.

#c++ #punto flotante