igualdad flotante/doble con cero exacto

Question

Tengo un algoritmo que usa floats o doubles para realizar algunos cálculos.

Ejemplo:

double a; 
double b; 
double c; 
... 
double result = c/(b - a); 
if ((result > 0) && (result < small_number)) 
{ 
    // result is relevant... 
} else { 
    // result not required... 
} 

Ahora, yo estoy preocupado por (b - a) podría ser cero. Si está cerca de cero pero no es cero, no importa porque el result estará fuera de rango para ser útil, y ya detecto que (como (b - a) se aproxima a cero, result se acercará a +/- inf, que no está en el rango 0 - small_number ...)

Pero si el resultado de (b - a) es exactamente cero, espero que algo dependiente de la plataforma ocurra debido a la división por cero. Podría cambiar la declaración if a:

if ((!((b-a) == 0.0)) && ((result = c/(b-a)) > 0) && (result < small_number)) { 

pero yo no sé si (b-a) == 0.0 detectará siempre igual a cero. He visto que hay múltiples representaciones para el cero exacto en coma flotante. ¿Cómo puedes probarlos a todos sin hacer un chequeo épsilon, que no necesito (un pequeño epsilon será ignorado en mi algoritmo)?

¿Cuál es la plataforma de manera independiente para comprobar?

EDIT:

No estoy seguro de si era lo suficientemente claro para la gente. Básicamente quiero saber cómo encontrar si una expresión como:

double result = numerator/denominator; 

dará lugar a una excepción de coma flotante, una excepción de la CPU, una señal del sistema operativo o alguna otra cosa .... sin realizar la operación y ver si se "lanzará" ... porque detectar un "tiro" de esta naturaleza parece ser complicado y específico de la plataforma.

¿Es suficiente ((denominator==0.0) || (denominator==-0.0)) ? "Will 'throw'" : "Won't 'throw'";?

Answer 1

Depende de cómo b y a obtuvieron sus valores. Zero tiene una representación exacta en formato de coma flotante, pero el problema más grande sería casi cero valores. Siempre sería seguro para comprobar:

if (abs(b-a) > 0.00000001 && ... 

Dónde 0,00000001 es cualquier valor que tiene sentido.

Answer 2

Usted podría intentar

if ((b-a)!=(a-b) && ((result = c/(b-a)) > 0) && (result < small_number))) { 
... 

Answer 3

ACTUALIZACIÓN (2016-01-04)

que he recibido algunos downvotes en esta respuesta, y me preguntaba si yo debería eliminarlo. Parece que el consenso (https://meta.stackexchange.com/questions/146403/should-i-delete-my-answers) es que la eliminación de respuestas solo debe hacerse en casos extremos.

Entonces, mi respuesta es incorrecta. Pero supongo que lo dejo porque ofrece un interesante tipo de experimento mental "pensar fuera de la caja".

===============

bingo,

Usted dice que quiere saber si == 0. ba

Otra manera de mirar esto es para determinar si a == b. Si a es igual a b, entonces b bis será igual a 0.

Otra idea interesante que encontré:

http://www.cygnus-software.com/papers/comparingfloats/Comparing%20floating%20point%20numbers.htm

Esencialmente, se toma las variables de coma flotante que tiene y le dice al compilador para reinterpretarlas (bit de bits) como enteros con signo, como en el siguiente:

if (*(int*)&b == *(int*)&a) 

enteros Luego se están comparando, y los puntos no flotantes. Quizás eso ayude? Tal vez no. ¡Buena suerte!

Answer 4

Creo que (b-a)==0 será verdadero exactamente en esos casos cuando el c/(b-a) fallaría porque (b-a) es cero. Las matemáticas float son complicadas, pero cuestionar esto es exagerar en mi opinión. También creo que el (b-a)==0 va a ser equivalente a b!=a.

Distinguir positivo 0 negativo tampoco es necesario. Ver p. aquí Does float have a negative zero? (-0f)

Answer 5

Así es como se hace: en lugar de la comprobación de (result < small_number), comprueba si hay

(abs(c) < abs(b - a) * small_number) 

Entonces todos tus problemas desaparecen! El cálculo de c/(b-a) nunca se desbordará si se aprueba esta prueba.

Answer 6

Para epsilon, existe una definición de plantilla estándar std :: numeric_limits :: epsilon(). Creo que comprobar la diferencia para ser más grande que std :: numeric_limits :: epsilon() debería ser lo suficientemente seguro como para proteger contra la división por cero. No hay dependencia de la plataforma aquí, supongo.

Answer 7

Supongo que puede usar fpclassify(-0.0) == FP_ZERO. Pero esto solo es útil si desea verificar si alguien puso algún tipo de cero en la variable de tipo flotante. Como ya se ha dicho, si desea verificar el resultado del cálculo, puede obtener valores muy cercanos a cero debido a la naturaleza de la representación.

Answer 8

En resumen, podemos saber que un número flotante es CERO exactamente si sabemos que representa el formato.

---

En la práctica, comparamos x con un número pequeño. Y si x es menor que este número, creemos que x es igual que CERO funcionalmente (pero la mayoría de las veces nuestro pequeño número es aún mayor que cero). Este método es muy fácil, eficiente y puede cruzar plataforma.

---

En realidad, la float y double han sido presentados por formato especial, y el se utiliza es IEEE 754 en el hardware actual, que divide el número en bits (mantisa) mantisa signo, exponente y.

lo tanto, si queremos comprobar si un número flotante es CERO exactamente, podemos comprobar si ambos exponente y mantisa es cero, ver here.

En IEEE 754 números de punto flotante binario, valores cero están representados por el exponente sesgado y significand ser ambos cero. El cero negativo tiene el bit de signo establecido en uno.

Tome float por ejemplo, podemos escribir un código simple para extraer el exponente y el bit de mantisa y luego verificarlo.

#include <stdio.h> 

typedef union { 
      float f; 
      struct { 
       unsigned int mantissa : 23; 
       unsigned int exponent : 8; 
       unsigned int sign :  1; 
      } parts; 
} float_cast; 


int isZero(float num) { 

    int flag = 0; 
    float_cast data; 
    data.f = num; 

    // Check both exponent and mantissa parts 
    if(data.parts.exponent == 0u && data.parts.mantissa == 0u) { 
     flag = 1; 
    } else { 
     flag = 0; 
    } 

    return(flag); 
} 


int main() { 

    float num1 = 0.f, num2 = -0.f, num3 = 1.2f; 

    printf("\n is zero of %f -> %d", num1, isZero(num1)); 
    printf("\n is zero of %f -> %d", num2, isZero(num2)); 
    printf("\n is zero of %f -> %d", num3, isZero(num3)); 

    return(0); 
} 

Resultados del ensayo:

# es igual a cero de 0,000000 -> 1
# es cero del -0.000000 -> 1
# es cero de 1,200000 -> 0

---

Más ejemplos:

Comprobemos cuando el float se convierte en CERO real con el código.

void test() { 
    int i =0; 
    float e = 1.f, small = 1.f; 
    for(i = 0; i < 40; i++) { 
     e *= 10.f; 
     small = 1.f/e; 
     printf("\nis %e zero? : %d", small, isZero(small)); 
    } 
    return; 
} 


is 1.0000e-01 zero? : NO 
is 1.0000e-02 zero? : NO 
is 1.0000e-03 zero? : NO 
is 1.0000e-04 zero? : NO 
is 1.0000e-05 zero? : NO 
is 1.0000e-06 zero? : NO 
is 1.0000e-07 zero? : NO 
is 1.0000e-08 zero? : NO 
is 1.0000e-09 zero? : NO 
is 1.0000e-10 zero? : NO 
is 1.0000e-11 zero? : NO 
is 1.0000e-12 zero? : NO 
is 1.0000e-13 zero? : NO 
is 1.0000e-14 zero? : NO 
is 1.0000e-15 zero? : NO 
is 1.0000e-16 zero? : NO 
is 1.0000e-17 zero? : NO 
is 1.0000e-18 zero? : NO 
is 1.0000e-19 zero? : NO 
is 1.0000e-20 zero? : NO 
is 1.0000e-21 zero? : NO 
is 1.0000e-22 zero? : NO 
is 1.0000e-23 zero? : NO 
is 1.0000e-24 zero? : NO 
is 1.0000e-25 zero? : NO 
is 1.0000e-26 zero? : NO 
is 1.0000e-27 zero? : NO 
is 1.0000e-28 zero? : NO 
is 1.0000e-29 zero? : NO 
is 1.0000e-30 zero? : NO 
is 1.0000e-31 zero? : NO 
is 1.0000e-32 zero? : NO 
is 1.0000e-33 zero? : NO 
is 1.0000e-34 zero? : NO 
is 1.0000e-35 zero? : NO 
is 1.0000e-36 zero? : NO 
is 1.0000e-37 zero? : NO 
is 1.0000e-38 zero? : NO 
is 0.0000e+00 zero? : YES <-- 1e-39 
is 0.0000e+00 zero? : YES <-- 1e-40