# Generating a pseudorandom number based on an entry

Posted on

#### Question :

I need to generate a random number based on another input number, so that for the same input number, the function must always generate the same output number.

For example, `meuRand(4)` would always return 236 (or any other number), and `meuRand(11)` would always return 1747. No problem if `meuRand(xx)` , with `xx` other than 4, also returned 236.

These values are for illustration purposes only.

For the time being, I have this function, which I found here , properly ported to C, as example:

``````double noise(int x) {
x = ((x << 13) ^ x);
x *= x * 15731;
x += 789221;
x *= x;
x += 1376312589;
x &= 0x7fffffff;
return 1.0 - ((double)x / 1073741824.0);
}
``````

This function returns values in the range of -1 to 1, but this is not a problem. The return being an integer or floating point is indifferent.

The ultimate goal of these random numbers is to actually generate a map with a Perlin Noise 2D. So I would like to test my algorithm with another random number generation function, and preferably, that this function would be quick to calculate.

It needs to be an algorithm, it can not be something like using this scheme in C, to always generate the same number based on 4, for example:

``````srand(4);
rand();
``````

Because the final code will not always run in C, C ++, C # etc.

The simplest solution I can offer is to simply use a hash function – like MD5 (or something more sophisticated – though I think it’s more important in your case that the function is fast ). They offer what you seek (same output for the same input), are widely supported by various systems and programming languages, and are considered – in theory at least (as they serve as the basis for many cryptographic systems) – as indistinguishable in the practice of random numbers.

And if what you want is a sequence of random numbers – not just one – you can still use the original number as the seed of a sequence, and from there incrementing a counter for generate the next number (or any other number after it). Ex.:

``````aleatorio(semente, indice) = MD5(semente + indice)
``````

Other algorithms (such as some proposed in a related question ) may be even more efficient, but if what search is portability I would use this as a first choice.

I just found a way to generate this kind of pseudo-random number created by Ken Perlin’s own creator Perlin Noise .

He left one of his talks available online here . Throughout the explanation, it takes you to one of your other sites , where it shows the original algorithm.

For completeness, and because the algorithm is not patented / available online (besides having already made the appropriate references), I’ll put algorithm from it here:

``````/* coherent noise function over 1, 2 or 3 dimensions */

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

#define B 0x100
#define BM 0xff

#define N 0x1000
#define NP 12   /* 2^N */
#define NM 0xfff

static p[B + B + 2];
static float g3[B + B + 2];
static float g2[B + B + 2];
static float g1[B + B + 2];
static start = 1;

static void init(void);

#define s_curve(t) ( t * t * (3. - 2. * t) )

#define lerp(t, a, b) ( a + t * (b - a) )

#define setup(i,b0,b1,r0,r1)
t = vec[i] + N;
b0 = ((int)t) & BM;
b1 = (b0+1) & BM;
r0 = t - (int)t;
r1 = r0 - 1.;

double noise1(double arg)
{
int bx0, bx1;
float rx0, rx1, sx, t, u, v, vec;

vec = arg;
if (start) {
start = 0;
init();
}

setup(0, bx0,bx1, rx0,rx1);

sx = s_curve(rx0);

u = rx0 * g1[ p[ bx0 ] ];
v = rx1 * g1[ p[ bx1 ] ];

return lerp(sx, u, v);
}

float noise2(float vec)
{
int bx0, bx1, by0, by1, b00, b10, b01, b11;
float rx0, rx1, ry0, ry1, *q, sx, sy, a, b, t, u, v;
register i, j;

if (start) {
start = 0;
init();
}

setup(0, bx0,bx1, rx0,rx1);
setup(1, by0,by1, ry0,ry1);

i = p[ bx0 ];
j = p[ bx1 ];

b00 = p[ i + by0 ];
b10 = p[ j + by0 ];
b01 = p[ i + by1 ];
b11 = p[ j + by1 ];

sx = s_curve(rx0);
sy = s_curve(ry0);

#define at2(rx,ry) ( rx * q + ry * q )

q = g2[ b00 ] ; u = at2(rx0,ry0);
q = g2[ b10 ] ; v = at2(rx1,ry0);
a = lerp(sx, u, v);

q = g2[ b01 ] ; u = at2(rx0,ry1);
q = g2[ b11 ] ; v = at2(rx1,ry1);
b = lerp(sx, u, v);

return lerp(sy, a, b);
}

float noise3(float vec)
{
int bx0, bx1, by0, by1, bz0, bz1, b00, b10, b01, b11;
float rx0, rx1, ry0, ry1, rz0, rz1, *q, sy, sz, a, b, c, d, t, u, v;
register i, j;

if (start) {
start = 0;
init();
}

setup(0, bx0,bx1, rx0,rx1);
setup(1, by0,by1, ry0,ry1);
setup(2, bz0,bz1, rz0,rz1);

i = p[ bx0 ];
j = p[ bx1 ];

b00 = p[ i + by0 ];
b10 = p[ j + by0 ];
b01 = p[ i + by1 ];
b11 = p[ j + by1 ];

t  = s_curve(rx0);
sy = s_curve(ry0);
sz = s_curve(rz0);

#define at3(rx,ry,rz) ( rx * q + ry * q + rz * q )

q = g3[ b00 + bz0 ] ; u = at3(rx0,ry0,rz0);
q = g3[ b10 + bz0 ] ; v = at3(rx1,ry0,rz0);
a = lerp(t, u, v);

q = g3[ b01 + bz0 ] ; u = at3(rx0,ry1,rz0);
q = g3[ b11 + bz0 ] ; v = at3(rx1,ry1,rz0);
b = lerp(t, u, v);

c = lerp(sy, a, b);

q = g3[ b00 + bz1 ] ; u = at3(rx0,ry0,rz1);
q = g3[ b10 + bz1 ] ; v = at3(rx1,ry0,rz1);
a = lerp(t, u, v);

q = g3[ b01 + bz1 ] ; u = at3(rx0,ry1,rz1);
q = g3[ b11 + bz1 ] ; v = at3(rx1,ry1,rz1);
b = lerp(t, u, v);

d = lerp(sy, a, b);

return lerp(sz, c, d);
}

static void normalize2(float v)
{
float s;

s = sqrt(v * v + v * v);
v = v / s;
v = v / s;
}

static void normalize3(float v)
{
float s;

s = sqrt(v * v + v * v + v * v);
v = v / s;
v = v / s;
v = v / s;
}

static void init(void)
{
int i, j, k;

for (i = 0 ; i < B ; i++) {
p[i] = i;

g1[i] = (float)((random() % (B + B)) - B) / B;

for (j = 0 ; j < 2 ; j++)
g2[i][j] = (float)((random() % (B + B)) - B) / B;
normalize2(g2[i]);

for (j = 0 ; j < 3 ; j++)
g3[i][j] = (float)((random() % (B + B)) - B) / B;
normalize3(g3[i]);
}

while (--i) {
k = p[i];
p[i] = p[j = random() % B];
p[j] = k;
}

for (i = 0 ; i < B + 2 ; i++) {
p[B + i] = p[i];
g1[B + i] = g1[i];
for (j = 0 ; j < 2 ; j++)
g2[B + i][j] = g2[i][j];
for (j = 0 ; j < 3 ; j++)
g3[B + i][j] = g3[i][j];
}
}
``````