Come rilevare overflow e underflow in virgola mobile a doppia precisione?

Question

devo seguenti variabili:

double dblVar1; 
double dblVar2; 

Essi possono avere valori grandi, ma meno di double max.

ho vari aritmetica sulle variabili di cui sopra come addizione, moltiplicazione e potenza:

double dblVar3 = dblVar1 * dblVar2; 
double dblVar4 = dblVar1 + dblVar2; 
double dblVar5 = pow(dblVar1, 2); 

In tutti sopra devo controllare di overflow e underflow. Come posso ottenere questo in C++?

Answer 1

Molto dipende dal contesto. Per essere perfettamente portatile, è necessario controllare prima dell' l'operazione, ad es. (per aggiunta):

if ((a < 0.0) == (b < 0.0) 
    && std::abs(b) > std::numeric_limits<double>::max() - std::abs(a)) { 
    // Addition would overflow... 
} 

La logica simile può essere utilizzata per i quattro operatori di base.

Se tutte le macchine che si target supportano IEEE (che è probabilmente il caso, se non si dispone di considerare mainframe), si può solo fare le operazioni, quindi utilizzare isfinite o isinf sui risultati.

Per underflow, la prima domanda è se un underflow graduale conta come underflow oppure no. In caso contrario, è sufficiente verificare se i risultati sono zero e a != -b farebbe il trucco. Se si desidera per rilevare un underflow graduale (che probabilmente è presente solo se si dispone di IEEE), allora è possibile utilizzare isnormal — questo sarà return false se i risultati corrispondono a un underflow graduale. (A differenza di troppo pieno, si prova per underflow dopo l'operazione.)

Answer 2

POSIX, C99, C++ 11 hanno <fenv.h> (e <cfenv> per C++ 11), che hanno funzioni per testare le eccezioni IEEE754 bandiere (che non hanno nulla a che fare con eccezioni C++, sarebbe troppo facile):

int feclearexcept(int); 
int fegetexceptflag(fexcept_t *, int); 
int feraiseexcept(int); 
int fesetexceptflag(const fexcept_t *, int); 
int fetestexcept(int); 

La bandiera è un campo di bit con i seguenti bit definiti:

FE_DIVBYZERO 
FE_INEXACT 
FE_INVALID 
FE_OVERFLOW 
FE_UNDERFLOW 

in modo da poter cancellare ° em prima delle operazioni e poi testarle dopo. Dovrai controllare la documentazione per l'effetto delle funzioni della libreria su di loro.

Answer 3

ISO C99 definisce le funzioni per interrogare e manipolare la parola di stato a virgola mobile. È possibile utilizzare queste funzioni per verificare le eccezioni non collegate quando è conveniente, piuttosto che preoccuparsi di esse nel mezzo di un calcolo.

Fornisce

FE_INEXACT 
FE_DIVBYZERO 
FE_UNDERFLOW 
FE_OVERFLOW 
FE_INVALID 

Per esempio

{ 
     double f; 
     int raised; 
     feclearexcept (FE_ALL_EXCEPT); 
     f = compute(); 
     raised = fetestexcept (FE_OVERFLOW | FE_INVALID); 
     if (raised & FE_OVERFLOW) { /* ... */ } 
     if (raised & FE_INVALID) { /* ... */ } 
     /* ... */ 
    } 

http://www.gnu.org/software/libc/manual/html_node/Status-bit-operations.html

Answer 4

Con un compilatore decente (che supporta il nuovo standard C++), è possibile utilizzare these funzioni:

#include <cfenv> 
#include <iostream> 

int main() { 
    std::feclearexcept(FE_OVERFLOW); 
    std::feclearexcept(FE_UNDERFLOW); 

    double overflowing_var = 1000; 
    double underflowing_var = 0.01; 

    std::cout << "Overflow flag before: " << (bool)std::fetestexcept(FE_OVERFLOW) << std::endl; 
    std::cout << "Underflow flag before: " << (bool)std::fetestexcept(FE_UNDERFLOW) << std::endl; 

    for(int i = 0; i < 20; ++i) { 
     overflowing_var *= overflowing_var; 
     underflowing_var *= underflowing_var; 
    } 

    std::cout << "Overflow flag after: " << (bool)std::fetestexcept(FE_OVERFLOW) << std::endl; 
    std::cout << "Underflow flag after: " << (bool)std::fetestexcept(FE_UNDERFLOW) << std::endl; 
} 

/** Output: 
    Overflow flag before: 0 
    Underflow flag before: 0 
    Overflow flag after: 1 
    Underflow flag after: 1 
*/