How to prevent overflow when using usual math functions exp() log()?

Question

All is in the title. How to check a possible overflow when using the two functions exp() and log()?

Answer 1

#include <errno.h>

When an oferflow occurs, then errno is set to ERANGE.

Next time, do your homework before asking.

Googling: "c++ exp" returned this as the first result http://www.cplusplus.com/reference/cmath/exp/
In the middle of the page, there is EXACTLY what you're looking for.

Answer 2

To expand the answer of @TheOtherGuy, you can cancel the operation if overflow occurs.

#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 3

The best way to check for overflow beforehand is to do so intelligently on a case-by-case basis.

Using your knowledge of logarithms and exponents, you should be able to identify potential overflows using properties like INT_MAX: examine these C++ Limitations

I threw a rough sample c++ execution together, assuming you know beforehand what limits you are attempting to follow.

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

If you're looking to catch the errors post mortem, examine errno in range.

Answer 4

For the exp() handling:

Just compare against a variable which you assign to log(FLT_MAX). FLT_MAX is biggest float. You can do this before calculating an exp(). Because log() is inverse of 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;
}

For the log() handling:

1)You cannot everflow log(x) before overflowing x. (for the upper bound)

2)Float's/Double's (x) precision is not enough to overflow to negative-infinity for log(x).

3)Make sure x is bigger than zero.

Answer 5

Better than prevent, you can catch the exception:

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