给定范围内的随机双精度，包括[-MAX_VALUE，MAX_VALUE]

Question

How do I implement a function getRandomDouble(min,max) which is able to handle +-Double.MAX_VALUE as parameter?

Online Research:

Most answers to this question are:

public Double getRandomDouble(double min, double max) {
    return min + (max-min)*Random.nextDouble(); 
}

This works fine if min and max are not +-Double.MAX_VALUE . If so, max-min is out of range or infinity. Changing the parameters to BigDecimal solves this issue, but the result is always a double with 50 zeros and no decimals. This is the result of a very large number ( 2*MAX_VALUE ) multiplied a double between [0,1] with only a view decimals.

So, I found a solution for +-MAX_VALUE like this:

public double getRandomDouble() {
    while(true) {
        double d = Double.longBitsToDouble(Random.nextLong());
        if (d < Double.POSITIVE_INFINITY && d > Double.NEGATIVE_INFINITY)
            return d;
    }
}

This works fine, but does not consider other bounds.

How can I combine both approaches to get random double in a given range that's maybe +-MAX_VALUE ?

Answer 1

If it's not working only with the max values, I think I have a solution.

Mathematically it should be the same:

You produce 2 random numbers and sum them up. Each number should be between -maxValue / 2 and +maxValue / 2 . That way the sum will be a random number between -maxValue and +maxValue .

public Double getRandomDouble(double min, double max) {
    double halfMin = min/2;
    double halfMax = max/2;
    double sum = halfMin + (halfMax-halfMin)*Random.nextDouble(); 
    return sum + (halfMin + (halfMax-halfMin)*Random.nextDouble());
}

Answer 2

You can do this by drawing two double random numbers. The first one is used to decide if you want a negative value or a positive value. The second one is used for the actual value from the negative part or the positive part. The approach will be like this:

Calculate the quotient between the range from zero to upper bound and the range from zero to lower bound. This will get you the information like "40% the value is positive, 60% the value is negative". Use the first random number to check which it is.

Then when you know if it is negative or positive use the normal approach to get a random number between zero and the lower/upper bound. This value can only be between 0 and MAX_VALUE (or MIN_VALUE ), so there will be no "overflow".

However, I don't know about the combined probability in this case, if it is the same random probability when drawing only one random double value. If you have a negative/positive split of about 5% and 95%, then the second random number will be hit a value inside the 5% or the 95%. Not sure if it still "random" or if it even creates unwanted bias.