Generating the same random number?

Question

How can I generate a random number that is the same depending on the x, y, and seed values? So if you kept choosing the exact same values for x, y, and seed, it would always return the same float from 0.0 to 1.0. Something like:

//Returns value from 0.0 to 1.0
public static float random(int seed, int x, int y) {
    ...
    return rand;
}

EDIT: I think I have found a method that would do the job (Sorry if I was asking the wrong question):

public static float random(int x, int y) {
    int n = x + y * 57;
    n = (n << 13) ^ n;
    return Math.abs((1.0f - ((n * (n * n * 15731 + 789221) + 1376312589) & 0x7FFFFFFF) / 1073741824.0f));
}

Answer 1

The Random class is a pseudo-random series generator, meaning that if you initialize it with the same seed that it will return the exact same series. So initialize Random with a combination of your arguments and request a new float number.

public static float random(int seed, int x, int y) {
    long superSeed = (seed << 32) ^ (x << 16) ^ y; // combine into a single long
    return new Random(superSeed).nextFloat();
}

Update

If I can interpret your question as: "How can I always generate the same terrain from a seed (with a single new Random() call?", then I would use something like this:

public static float[][] randomTerrain(long seed, int w, int h) {
    Random random = new Random(seed);
    float[][] terrainRandom = new float[w][h];
    for (int x = 0; x < w; x += 1) {
        for (int y = 0; y < h; y += 1) {
            terrainRandom[x][y] = random.nextFloat();
        }
    }
    return terrainRandom;
}

This will generate the same array of randomness from the same seed every time.

This stores the randomness in an array, but you could actually integrate this into your terrain generating code so you don't really have to store the entire array first before using it.

Answer 2

Depends on the value range of x and y. In your case you have two ints, they do fit into a long for the Random() seed.

The trivial case looks like: It will return the same float in range of 0..1 for same x+y. However it might also return the same float for different combinations.

long seed = ((long)x << 32) + y;
Random r = new Random(seed);
r.nextLong(); // discard
return r.nextFloat();

Random internally will reduce the 64bit long to 48bit state. I would add the r.nextLong() call just to make sure you do not get the first few bytes which are biased.

Answer 3

Use some combination of addition, exclusive or (^) and multiplication with large primes to combine seed, x, y and some large constant to get a random integer. Then scale this integer to a float in the desired range.

Beware that the quality of the random numbers depends on the precise choice of these values. If you want high quality random numbers you need to test them with something like the Diehard tests, and fiddle the constants until the quality is good enough.

Also, since these operations are linear an intelligent adversary may be able to predict your random numbers after seeing a few of them. If this is a problem you should instead use some cryptographic algorithms to combine x and y and a key.

Answer 4

How about Math.sin(seed + x + y) ?