Come prevenire l'overflow quando si usano le funzioni matematiche usuali exp() log()?

Question

Tutto è nel titolo. Come verificare un possibile overflow quando si utilizzano le due funzioni exp() e log()?

Answer 1

Per espandere la risposta di @TheOtherGuy, è possibile annullare l'operazione in caso di overflow.

#include <stdio.h> 
#include <math.h> 
#include <errno.h> 

int main(void) 
{ 
    double param, result; 

    errno = 0; 
    param = 1e3; 
    result = exp (param); 
    if (errno == ERANGE) { 
     printf("exp(%f) overflows\n", param); 
     result = param; 
    } 
    printf ("The exponential value of %f is %f.\n", param, result); 
    return 0; 
} 

Answer 2

#include <errno.h> 

Quando si verifica un oferflow, quindi errno è impostato ERANGE.

La prossima volta, fare il vostro lavoro prima di chiedere.

Googling: "C++ exp" ha prodotto questo come il primo risultato http://www.cplusplus.com/reference/cmath/exp/
Al centro della pagina, v'è esattamente quello che stai cercando.

Answer 3

Il modo migliore per controllare in anticipo l'overflow è farlo in modo intelligente, caso per caso.

Usando la vostra conoscenza dei logaritmi ed esponenti, si dovrebbe essere in grado di identificare potenziali overflow utilizzando le proprietà come INT_MAX: esaminare questi C++ Limitations

ho gettato un campione di massima C++ esecuzione insieme, a patto di sapere in anticipo quali limiti si sta tentando da seguire.

#include <iostream> 

// nTh root calculator 
bool is_exp_overflow(int input_val, int exponent) 
{ 
    my_max = pow(INT_MAX, (1/exponent); 
    if (input_val > my_max) 
    { 
     return true; 
    } 
    else 
     return false; 
} 

void runExp(int my_input, int my_exp) 
{ 
    // Do maths 
} 

int main() 
{ 
    int my_input = 0; 
    int my_exp = 0; 
    std::cout << "Enter test value\n"; 
    std::cin >> my_input; 
    std::cout << "Enter test exponent\n"; 
    std::cin >> my_exp; 
    bool exp_unsafe = 1; 
    exp_unsafe = is_exp_overflow(my_input, my_exp); 

    if (!exp_unsafe) 
     runExp(my_input, my_exp); 
    else 
     std::cout << "Code is unsafe\n"; 

    return 0; 
} 

Se stai cercando di catturare gli errori post mortem, esaminare errno in range.

Answer 4

Per la movimentazione exp():

Basta confrontare con una variabile che si assegna il login (FLT_MAX). FLT_MAX è il più grande float. È possibile eseguire questa operazione prima del calcolando un exp(). Perché log() è inverso di exp().

#include <iostream> 
#include <math.h> 
using namespace std; 

int main() 
{ 
    float a=1E+37f; // an example of maximum finite representable floating-point number. 
    //max value can change with platform so, 
    //either use definitions or use a function you wrote 
    // a= getMaxFloat(); or a=FLT_MAX 
    float b=log(a); // limit of float to give in exp(); 
    float c=3242325445.0f; // test variable 
    cout << "Hello world!" << endl; 
    if(c>b){cout<<"you should not take exp of "<<c<<endl;}else{cout<<"go on"<<endl;} 

    return 0; 
} 

Per la gestione di log():

1) Non è possibile Everflow log (x) prima traboccante x. (per il limite superiore)

2) La precisione di Float/Double (x) non è sufficiente per l'overflow per l'infinito negativo per log (x).

3) Assicurarsi che x sia maggiore di zero.

Answer 5

Meglio prevenire, si può prendere l'eccezione:

try { 
    z=exp(n); 
} catch (...) { 
    puts("Can't calcute exp..."); 
}