Random number between INT_MAX & INT_MIN

Question

Well I feel my question is bit more complex compared to other questions. I realized this while trying to solve it.

I tried using

int number = rand() % (INT_MAX - INT_MIN + 1) + INT_MIN;
rand() % (INT_MAX + INT_MIN + 1) + rand() % INT_MIN;

However, I got floating point exception 8 error. No warnings, that's really strange!

Also, from time.h, I used srand((unsigned)time(NULL)) for new random number every time I execute my code.

But whatever I try either I get incorrect results or floating point exception.

I am really curious as to overflow & underflow, how it's happening and can such a random number be actually generated?

I basically want to generate a number in C greater than INT_MIN and lesser than INT_MAX.

I tried lots of logic but I got incorrect result.

Answer 1

(INT_MAX - INT_MIN + 1) is probably going to overflow (since they're int literals) and produce 0, explaining your error (you're dividing by 0).

Changing to ((long)INT_MAX - INT_MIN + 1) would avoid the overflow (assuming long is bigger than int, which is not the case for Visual Studio on Windows, where you'd need to cast to long long).

That said, you're not going to get the results you want with a single rand call; it only produces numbers between 0 and RAND_MAX; RAND_MAX is usually 32767, so you'd end up covering only a trivial portion of the possible range for int on most systems (where int is usually 32 bits).

To make this work, you'd need to generate enough bits to fill an int. Something like:

#include <stdlib.h>
#include <limits.h>
#include <math.h>

/* Assumes srand() has been called with an appropriate seed at some point
   Code assumes C99 is available; minor tweaks needed for older compilers.
 */
int gen_random_int() {
    const int BITS_PER_RAND = (int)(log2(RAND_MAX/2 + 1) + 1.0); /* Or log(RAND_MAX + 1) / log(2) with older language standards */
    int ret = 0;
    for (int i = 0; i < sizeof(int) * CHAR_BIT; i += BITS_PER_RAND) {
        ret <<= BITS_PER_RAND;
        ret |= rand();
    }
    return ret;
}

You don't even need to bother with INT_MIN and INT_MAX, because this fills in an int directly; the excess bits of random generated overflow and get discarded.

Answer 2

INT_MAX - INT_MIN + 1 is int overflow and therefore undefined behavior.

The behavior your system experienced was a divide by 0 as that is often, though not specified, result of INT_MAX - INT_MIN + 1 --> 0.

rand() generates an int in the range [0...RAND_MAX]. Since RAND_MAX <= INT_MAX, it could take multiple calls to construct an int in the range [0...INT_MAX] let alone in your quest of [INT_MIN...INT_MAX].

Below is a generic approach. It is not highly efficient but simple and obviously amendable for all sorts of types.

int rand_int(void) {
  union {
    int i;
    unsigned char uc[sizeof (int)];
  } u;
  for (size_t i = 0; i < sizeof u.uc; i++) {
    u.uc[i] = rand();
  }
  return u.i;
}

It technically can cause UB on rare machines that have a trap value for int.