float/doppia uguaglianza con lo zero esatto

Question

Ho un algoritmo che utilizza floats o doubles per eseguire alcuni calcoli.

Esempio:

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

Ora, io sono preoccupato per (b - a) potrebbe essere pari a zero. Se è vicino a zero ma non a zero, non importa perché il result sarà fuori portata per essere utile, e già noto che (dato che (b - a) si avvicina a zero, result si avvicina a +/- inf, che non è nel variare 0-small_number ...)

Ma se il risultato di (b - a) è esattamente pari a zero, mi aspetto che qualcosa dipendente dalla piattaforma accadrà a causa di dividere per zero. Ho potuto modificare l'istruzione if a:

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

ma non so se (b-a) == 0.0 rileverà sempre uguaglianza con zero. Ho visto che ci sono più rappresentazioni per lo zero esatto in virgola mobile? Come puoi testarli tutti senza fare qualche controllo epsilon, cosa di cui non ho bisogno (un piccolo epsilon verrà ignorato nel mio algoritmo)?

Qual è il modo indipendente dalla piattaforma per controllare?

EDIT:

Non so se era abbastanza chiaro alla gente. Fondamentalmente voglio sapere come trovare se un'espressione come:

double result = numerator/denominator; 

si tradurrà in un'un'eccezione a virgola mobile, un'eccezione cpu, un segnale dal sistema operativo o qualche altra cosa .... senza eseguire effettivamente il funzionamento e vedere se "getterà" ... perché rilevare un "lancio" di questa natura sembra essere complicato e specifico della piattaforma.

È sufficiente il numero ((denominator==0.0) || (denominator==-0.0)) ? "Will 'throw'" : "Won't 'throw'";?

Answer 1

Dipende dal modo in cui b e a hanno ottenuto i loro valori. Zero ha una rappresentazione esatta nel formato in virgola mobile, ma il problema più grande sarebbe quasi-ma-non-proprio zero valori. Sarebbe sempre sicuro controllare:

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

Dove 0,00000001 è qualunque valore abbia senso.

Answer 2

Si potrebbe provare

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

Answer 3

UPDATE (2016-01-04)

ho ricevuto alcune downvotes su questa risposta, e mi chiedevo se devo semplicemente eliminarlo. Sembra che il consenso (https://meta.stackexchange.com/questions/146403/should-i-delete-my-answers) sia che l'eliminazione delle risposte dovrebbe essere eseguita solo in casi estremi.

Quindi, la mia risposta è sbagliata. Ma immagino che me ne stia andando perché offre un interessante esperimento di pensiero "fuori dagli schemi".

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

Bingo,

Tu dici che vuoi sapere se ba == 0.

Un altro modo di guardare questo è per determinare se un == b. Se a è uguale a b, allora BA sarà pari a 0.

Un'altra idea interessante che ho trovato:

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

In sostanza, si prende le variabili in virgola mobile che avete e dite al compilatore di reinterpretare loro (un po ' per bit) come interi con segno, come nel seguente:

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

interi Poi si confrontano e punti non galleggianti. Forse questo ti aiuterà? Forse no. In bocca al lupo!

Answer 4

Credo che (b-a)==0 sarà vero esattamente in quei casi in cui il c/(b-a) non riuscirebbe a causa di (b-a) zero. La matematica fluttuante è complicata, ma a mio avviso questo è esagerato. Inoltre, credo che lo (b-a)==0 sarà equivalente a b!=a.

La distinzione positiva e negativa 0 non è necessaria. Vedi per es. qui Does float have a negative zero? (-0f)

Answer 5

Ecco come si fa: invece di controllare per (result < small_number), si controlla la

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

Quindi tutti i tuoi problemi spariscono! Il calcolo di c/(b-a) non verrà mai superato se questo test viene superato.

Answer 6

Per epsilon, in c'è una definizione di modello standard std :: numeric_limits :: epsilon(). Immagino che controllare la differenza sia maggiore di std :: numeric_limits :: epsilon() dovrebbe essere abbastanza sicuro da proteggere dalla divisione per zero. Nessuna dipendenza dalla piattaforma, immagino.

Answer 7

Immagino che tu possa usare fpclassify(-0.0) == FP_ZERO. Ma questo è utile solo se vuoi verificare se qualcuno ha inserito qualche tipo di zero nella variabile di tipo float. Come molti hanno già detto se si desidera verificare il risultato del calcolo, è possibile ottenere valori molto vicini allo zero a causa della natura della rappresentazione.

Answer 8

In breve, possiamo sapere che un numero variabile è ZERO esattamente se sappiamo che rappresenta il formato.

---

In pratica, confrontiamo x con un piccolo numero. E se x è inferiore a questo numero, pensiamo che x sia uguale a ZERO funzionalmente (ma la maggior parte del tempo il nostro piccolo numero è ancora grande di zero). Questo metodo è molto semplice, efficiente e può essere multipiattaforma.

---

realtà, il float e double sono state presentate da formato speciale, e ampiamente usato uno è IEEE 754 in hardware corrente che divide il numero in segno, esponente e mantissa bit (significante).

Quindi, se vogliamo controllare se un numero float è ZERO esattamente, siamo in grado di controllare se sia esponente e mantissa è pari a zero, vedi here.

In IEEE 754 numeri in virgola mobile binari, valori zero sono rappresentati dal esponente polarizzato e significando entrambi essendo zero. Lo zero negativo ha il bit di segno impostato su uno.

Prendete float per esempio, possiamo scrivere un semplice codice per estrarre esponente e mantissa po 'e poi controllare.

#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); 
} 

I risultati dei test:

# è pari a zero di 0.000000 -> 1
# è pari a zero di -,000000 -> 1
# è pari a zero di 1,200 mila -> 0

---

Altri esempi:

Controlliamo quando lo float diventa ZERO reale con codice.

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