Stable mapping of an integer to a random number

Question

I need a stable and fast one way mapping function of an integer to a random number. By "stable" I mean that the same integer should always map to the same random number. And by "random number" I actually mean "some number which behaves like random".

e.g.

1 -> 329423
2 -> -12398791234
3 -> -984
4 -> 42342435
...

If I had enough memory (and time) I would ideally use:

for( int i=Integer.MIN_VALUE; i<Integer.MAX_VALUE; i++ ){
    map[i]=i;
}
shuffle( map );

I could use some secure hash function like MD5 or SHA but these are to slow for my purposes and I don't need any crypto/security properties.

I only need this in one way. So I will never have to translate the random number back to its integer.

Background: (For those who want to know more)

I'm planing to use this to invalidate a complete cache over a given amount of time. The invalidation is done "randomly" on access of the cache member with an increasing chance while time passes. I need this to be stable so that isValid( entry ) does not "flicker" and for consistent testing. The input to this function will be the java hash of the key of the entry which typically is in the range of "1000"-"15000" (but can contain some other stuff, too) and comes in bulks. The invalidation is done on the condition of:

elapsedTime / timeout * Integer.MAX_VALUE > abs( random( key.hashCode() ) )

EDIT: (this is to long for a comment so I put it here)

I tried gexicide's answer and it turns out this isn't random enough. Here is what I tried:

        for( int i=0; i<12000; i++ ){

            int hash = (""+i).hashCode();

            Random rng = new Random( hash );
            int random = rng.nextInt();

            System.out.printf( "%05d, %08x, %08x\n", i, hash, random );

        }

The output starts with:

00000, 00000030, bac2c591
00001, 00000031, babce6a4
00002, 00000032, bace836b
00003, 00000033, bac8a47e
00004, 00000034, baab49de
00005, 00000035, baa56af1
00006, 00000036, bab707b7
00007, 00000037, bab128ca
00008, 00000038, ba93ce2a
00009, 00000039, ba8def3d
00010, 0000061f, 98048199

and it goes on in this way.

I could use SecureRandom instead:

    for( int i=0; i<12000; i++ ){

            SecureRandom rng = new SecureRandom( (""+i).getBytes() );
            int random = rng.nextInt();

            System.out.printf( "%05d, %08x\n", i, random );
        }

which indeed looks pretty random but this is not stable anymore and 10 times slower than the method above.

Answer 1

Although you never specified it as a requirement you'll probably want a full 1:1 mapping. This is because the number of possible input values is small. Any output that can occur for more than one input implies another output which can never happen at all. If you have output values which are impossible then you have a skewed distribution.

Of course, if your input is skewed then your output will be skewed anyway, and there's not much you can do about that.

Anyway; this makes it a unique int to int hash.

Simply apply a couple of trivial, independent 1:1 mapping functions until things are suitably distributed. You've already isolated one transform from the Random class, but I suggest mixing it with some other transforms like shifts and XORs to avoid individual weaknesses of different algorithms.

For example:

public static int mapInteger( int value ){

    value *= 1664525;
    value += 1013904223;
    value ^= value >>> 12;
    value ^= value << 25;
    value ^= value >>> 27;
    value *= 1103515245;
    value += 12345;

    return value;
}

If that's good enough then you can make it faster by deleting lines at random (I suggest you keep at least one multiply) until it's not good enough anymore, and then add the last deleted line back in.

Answer 2

Use a Random and seed it with your number:

Random generator = new Random(i);
return generator.nextInt();

As your testing exposes, the problem with this method is that such a seed creates a very poor random number in the first iteration. To increase the quality of the result, we need to run the random generator a few times; this will fill up the state of the random generator with pseudo-random values and will increase the quality of the following values.

To make sure that the random generator spreads the values enough, use it a few times before outputting the number. This should make the resulting number more pseudo-random:

Random generator = new Random(i);
for(int i = 0; i < 5; i++) generator.nextInt();
return generator.nextInt();

Try different values, maybe 5 is enough.

Answer 3

The answer of gexicide is the correct (and the most simple) one. Just one note:

Running this 1,000,000 times on my system takes about 70ms. (Which is pretty fast.) But it involves at least two object creations and feeds the GC. It would be better if this could be done on the stack and not using object creation at all.

Looking at the sources of Random class it shows that there is some code to make it callable multiple times and to make it threadsafe which can be removed.

So I ended up with a reimplementation in one method:

public static int mapInteger( int value ){

    // initial scramble
    long seed = (value ^ multiplier) & mask;

    // shuffle three times. This is like calling rng.nextInt() 3 times
    seed = (seed * multiplier + addend) & mask;
    seed = (seed * multiplier + addend) & mask;
    seed = (seed * multiplier + addend) & mask;

    // fit size
    return (int)(seed >>> 16);
}

(multiplier, addend and mask are some constants used by Random)

Running this 1,000,000 times gives the same result but takes only 5ms and is therefor 10 times faster.

BTW: This happens to be another piece of code from The Old Man - again. See Donald Knuth, The Art of Computer Programming, Volume 2, Section 3.2.1