you can fill an array with random numbers in setup. and use it instead of the random function.

Sure, but my point is that the random function itself already acts like it is accessing an array. 

it isnt something i would recommend as well :) but as it is just a theoretical question, i have no explicit answer to it :)

Random number generators doesn't access an array... These are functions that, given a seed, return a pseudo-random number. Pseudo because if given the same number, they return the same result. The result is the new seed, or is used to make the new seed, so that the next number is different.

It uses the previous return as seed? Ahhh that's cool.. Thanks PhiLho

http://en.wikipedia.org/wiki/Pseudorandom_number_generator
http://www.math.utah.edu/~alfeld/Random/Random.html

Hey,
Urgh, i am a lil' confused. Not able to clear this out. 
If i am passing some argument into RandomSeed(value), what does it mean?

There is no RandomSeed() in Processing, only randomSeed().

If you give the function the same number, the sequence of numbers given by random() calls will be the same.
Mmm, a bit confusing...
Let me illustrate that:

1. randomSeed(42);
2. for (int i = 0; i < 10; i++)
3. {
4.   println(random(100));
5. }
6. println("Next");
7. randomSeed(42);
8. for (int i = 0; i < 10; i++)
9. {
10.   println(random(100));
11. }

The second call to randomSeed() resets the generator at its initial state.

Hello all the seedRandomers,

I have a question why when I put my randomSeed in my loop for i have always a same result ?
SeedIN : 7.3096776. I stop Processing and restart same result. There is a link between the value of the seed and the value of my random. and if yes. Which one ?

Thank you

1. for ( int i =0 ; i < 10; i++) {
     randomSeed(0) ;
     println("SeedIN " + random(0,10)) ;
   }
     randomSeed(0) ;
   for ( int i =0 ; i < 10 ; i++) {
   
     println("SeedOUT " + random(0,10)) ;
   }
   
   for ( int i =0 ; i < 5 ; i++) {
     println("NoSeed " + random(0,10)) ;
   }

The same seed will always return the same sequence of "random" numbers. 

That's precisely the point of randomSeed: if you use an initial number, and memorize it, it allows to replay a random sequence, eg. a game level.

Tank

I understand this property of randomSeed. My question was in the case of "SeedIn" it's always "7.3096776" with Seed "0" and random "O to 10".
example :
randomSeed(1)
random(0,10)
SeedIN 7.3087816

randomSeed(10)
random(0,10)
SeedIN 7.304302 when the seed change the float change why ?

randomSeed(100)
random(0,10)
SeedIN 7.220096

randomSeed(0)
random(0,25)
SeedIN 18.274195

randomSeed(100)
random(0,25)
SeedIN 18.05024

randomSeed(100)
random(10,25)
SeedIN 20.830143

randomSeed(-100) negative seed
random(10,25)
SeedIN 14.161793 when the seed is negative the value of int change why ?

I just want understand the function exactly. there is a link white the gap of radom(a,b) the value of the seed, if the value is positive or negative, why the zero is like a positive value.
May be it's nor reallly interesting question but it's my question ! :)

" I understand this property of randomSeed."
Sorry, but I am not sure you fully understood it.

The randomSeed value is just the starting point of the random sequence. If you give always the same starting point, the sequence will always be the same. That's why it is called a pseudo-random number generator.
There are some true random number generators, based on hardware devices, like measuring heat noise in an electronic chip.

So, if you change the seed, the starting number will change as well. That's the point of having different starting points. The fact the seed is negative gives no difference, it is just another number. Idem for zero. These are just regular, distinct numbers.
The interval you give to the generator also affects the result.
If I change slightly one of your example:

1. randomSeed(100);
2. println(random(0,25));
3. //SeedIN 18.05024
4. 
   
5. randomSeed(100);
6. println(random(0,25));
7. //SeedIN 18.05024
8. 
   
9. randomSeed(100);
10. println(random(10,25));
11. //SeedIN 20.830143
12. 
    
13. randomSeed(100);
14. println(random(0,25));
15. //SeedIN 18.05024
16. 
    
17. randomSeed(100);
18. println(random(10,25));
19. //SeedIN 20.830143

Same seed + same interval = same value.
Change seed or interval, you will get a different starting point.

I try to understand, I swear.

My new question why 20,... and not 21,... or 5,... in this case, for example. There is an algorythm, a law, a trick behind that?
There is a link between the seed and the range of the random ?

1. randomSeed(100);
2. println(random(10,25));
3. //SeedIN 20.830143

My second answer to this topic give links to pages explaining how these numbers are generated.
When I started computing (around 1979 with a TI-57, one of the first programmable calculators), there was not such RNG (random number generator), so we use hand-made ones, with some stats to see if generation was reliable.
Here is a little sketch illustrating such hand-made RNG (in an absolutely non-scientific design) compared with the built-in one, and how to visualize the quality of the generation.
As you can see, the random numbers are just a sequence of numbers made from previous value(s), starting with a seed.
There are better methods to generate them (a well known one is the Mersenne-Twister one), but you get the idea.

1. // That's also the seed!
2. float currentRandom = 0.1717;
3.  
4. int NB = 100;
5. float[] handRandom = new float[NB];
6. float[] procRandom = new float[NB];
7.  
8. float interval;
9.  
10. void setup()
11. {
12.   size(800, 400);
13.   smooth();
14.   noStroke();
15.  
16.   interval = width / NB / 2;
17.   println(interval);
18. }
19.  
20. void draw()
21. {
22.   background(255);
23.  
24.   // Add a new item with our generator
25.   int rndH = int(getRandom(0, NB));
26. //  println(rndH);
27.   handRandom[rndH]++;
28.   // Add a new item with the Processing's generator
29.   int rndP = int(random(NB));
30.   procRandom[rndP]++;
31.   if (handRandom[rndH] == height || procRandom[rndP] == height)
32.     noLoop(); // Stop
33.  
34.   for (int i = 0; i < NB; i++)
35.   {
36.     fill(#55AAFF);
37.     rect(interval * (2 * i), height - handRandom[i], interval, handRandom[i]);
38.    
39.     fill(#FFEE55);
40.     rect(interval * (2 * i + 1), height - procRandom[i], interval, height);
41.   }
42. }
43.  
44. /** Returns a random number between 0 (included) and 1 (excluded). */
45. float getRandom()
46. {
47.   currentRandom = sq(PI / (currentRandom + 1)) % 1;
48.   return currentRandom;
49. }
50.  
51. float getRandom(float a, float b)
52. {
53.   return (b - a) * getRandom() + a;
54. }

Thanks,

I take time to read your answer when I'm back from hollyday...
But if you code since 1979, you're like a legend in the Matrice and I'll read that with a lot of respect :)

Yes, PhiLo is definitely to be treated with a lot of respect.

I'm come back from hollyday and I take a time to read the code you post about the seed "root !!!!" of the Random. It's very interresting and instrutive. I'm very close to understand. Thanks a lot.