C ++-g ++将int转换为double会给出负值

Question

Was working on a project with mingw on windows :

C:\Users\...>g++ -dumpversion
4.5.0

When I compiled the code under g++ v 4.2.4 I was getting a segmentation fault - after couple hours I pinned it down to the line :

double decimal = ((double) rand()) / (RAND_MAX + 1);

For some reason this was giving negative values (and one thing led to another). What reason ?

Edit : cpp :

#include <iostream>
#include "Random.h"
#include <math.h>

using namespace std;
double Random::exponential(int T) {
    double decimal = ((double) rand()) / (RAND_MAX + 1);
    //  std::cout << "decimal : " << decimal << std::endl;
    return log(1 - decimal)*(-T);
}
//etc

h:

#ifndef RANDOM_H
#define RANDOM_H

#include <cstdlib>
#include <math.h>
class Random {
public:
    static double exponential(int T);
    static int random_int(int min, int max);
    static bool coin(); //50% true 50% false
};

#endif  /* RANDOM_H */

just noticed the double include (of math.h) but this shouldn't be an issue

Answer 1

In your case, RAND_MAX is the maximum value for the integer type it is stored in, so RAND_MAX + 1 gives you the maximum negative value. Technically this is signed integer overflow which is undefined behaviour so anything can happen.

You need to do, as J-16 pointed out,

double decimal = (double)rand() / ((double)RAND_MAX + 1);

Answer 2

In your environment, RAND_MAX is probably set to the highest positive number, such as 0x7fff (32767). When you add one to that, it actually wraps around to the lowest negative number, such as 0x8000 (-32768). This all assumes two's complement of course and that the number will wrap, neither of which are mandated by the standard).

So, because you're dividing the positive-or-zero value from rand by a negative value, you'll end up with a negative number most of the time, and zero occasionally.

You can use RAND_MAX in the division instead of RAND_MAX+1 . This will avoid giving you a negative number but then you'll run into another problem.

Because there's a possibility that rand will return RAND_MAX , the division may give you a result of 1. When you then try to calculate log (1 - decimal) * (-T) , that's taking the logarithm of zero and you'll end up with an error: log(0) is not defined in mathematics.

I would suggest simply avoiding that problem by using something like this:

double Random::exponential (int T) {
    int randVal = rand();
    while (randVal == RAND_MAX)
        randVal = rand();

    double decimal = (double) randVal / RAND_MAX;
    return log (1 - decimal) * (-T);
}

This will avoid the edge cases at the cost of the occasional double call to rand .