Read the documentation: Random() is working as intended.
The Processing Reference includes a couple of built-in methods for generating random numbers that you might find easier to implement.

Thank you for answering, i followed your link and can only conclude that my (above) code match the criteria. Still, it won't explain why i see a nice image over and over again, or do i read over it?

I also checked the Processing Reference, and the only thing i can think off, is using Perlin Noise. Except, it goes for me too far because i was converting a Java code to Processing. I do hope so that Random works correct in Processing?

OK - I took you at your word, so assumed that the following bit from the docs applied in your use-case:

If two instances of Random are created with the same seed, and the same sequence of method calls is made for each, they will generate and return identical sequences of numbers.

It was early.  I was hungover.  And I was wrong (about the above).  Except that my answer still stands:  Random() is working as intended... and of course Random() works correctly in Processing: it's a Java class and it should behave just as it would in pure Java.  The problem is more likely to be the method it uses to generate 'random' numbers.  Notice the wording on the nextFloat() method:

 Returns the next pseudorandom, uniformly distributed float

'pseudo' implies that it isn't truly random and 'uniformly distributed' would suggest it's not necessarily the best tool for what you're trying to achieve.  You might want to check out the random number generator article on wikipedia for more info.

In this case I suspect one of the noise generators would definitely be a better choice.

Ah, weird. I have to work around it, i found this example code

1. // Example: 2D Array
2. size(200,200);
3. int cols = width;
4. int rows = height;
5. // Declare 2D array
6. int[][] myArray = new int[cols][rows];
7. // Initialize 2D array values
8. for (int i = 0; i < cols; i++) {
9. for (int j = 0; j < rows; j++) {
10. myArray[i][j] = int(random(255));
11. }
12. }
13. // Draw points
14. for (int i = 0; i < cols; i++) {
15. for (int j = 0; j < rows; j++) {
16. stroke(myArray[i][j]);
17. point(i,j);
18. }
19. }
    

This solves my needs. It can be found in http://processing.org/learning/2darray/
Thanks!

It is indeed simpler to use the random() function.
But for the record, you should make only one Random instance and use it through all the code. And you can use setSeed() (usually with a number like System.nanoTime()) to get varied results.

Hi,

That's a good tip. I did found some wierd code in http://download.oracle.com/javase/1.4.2/docs/api/java/util/Random.html#setSeed(long) , and i combined it with the System.nanotime. It looks pretty random now. Sometimes the string get to short, resulting in a error, so i added PI (if somebody knows a beter idea, let me know).

1. void draw() {
2.   String random = str(((System.nanoTime()^ 0x5DEECE66DL)
3.     & ((1L << 48) - 1)));
4.   random=random+PI;
5.   println(int(random.substring(6,9)));
6. }

I found something else

public long randomLong() {
  x ^= (x << 21);
  x ^= (x >>> 35);
  x ^= (x << 4);
  return x;
}

Except, this does not work in Processing. Does it have to do with the compiler?
Here is the link: http://www.javamex.com/tutorials/random_numbers/xorshift.shtml

What "doesn't work"?

The code! :)

1. Long x=31l;
2. void setup(){
3.   x ^= (x << 21);
4.   x ^= (x >>> 35);
5.   x ^= (x << 4);
6.   print(x);
7. }

It always returning the same number.

Yes, the code doesn't work, but that's your code which is faulty! (as I guessed) As said in the article you reference (" Starting with some non-zero seed value of x — e.g. from System.nanoTime() — the algorithm looks as follows"), and as said by sansumbrella, " your random generator has a consistent seed", since you always give it 31 as starting point (and you should use a long, not a Long...).

It is a function in the pure sense, ie. for same entry, it will give always the same output. The idea of this generator is that the sequence of numbers on successive calls will be randomly distributed. But like all pseudo-random number generators, for a given seed/input, it will always give the same sequence. Which is actually an interesting particularity for some tests.

Oops.. It was a test! :)

1. int astart,aend,bstart,bend,cstart,cend,
2. dstart,dend,estart,eend,fstart,fend,gstart,gend,
3. hstart,hend;
4. long x;
5. void setup() {
6.   noLoop();
7.   println("Hold on, calculating!");
8.   print("Xor fast random starting!");
9.   x=System.nanoTime(); 
10.   astart=millis();
11.   for (int i=0;i<2147483646/100;i++) {   
12.     x ^= (x << 21);
13.     x ^= (x >>> 35);
14.     x ^= (x << 4);   
15.     randomSeed(x); 
16.     int y=(int)random(0,100);
17.     if ( ( i % 1000000 ) == 0 ) print(".");
18.   }
19.   aend=millis(); 
20.   println("done");
21.   print("Processing nextInt random starting!"); 
22.   Random random = new Random(); 
23.   bstart=millis();
24.   for (int i=0;i<2147483646/100;i++) {
25.     randomSeed( System.nanoTime() );   
26.     random.nextInt(100);
27.     if ( ( i % 1000000 ) == 0 ) print(".");
28.   }
29.   bend=millis();
30.   println("done");
31.   print("Processing normal random starting!");   
32.   cstart=millis();
33.   for (int i=0;i<2147483646/100;i++) {
34.     randomSeed( System.nanoTime() );
35.     int y=(int)random(0, 100);     
36.     if ( ( i % 1000000 ) == 0 ) print(".");
37.   }
38.   cend=millis();
39.   println("done");
40.   print("Java normal random starting!"); 
41.   dstart=millis();
42.   for (int i=0;i<2147483646/100;i++) {
43.     random.setSeed( System.nanoTime() );
44.     int y=(int)Math.random()*99+1;
45.     if ( ( i % 1000000 ) == 0 ) print(".");
46.   }
47.   dend=millis();
48.   println("done");
49.   print("Testing system.nanotime() starting!");   
50.   estart=millis();
51.   for (int i=0;i<2147483646/100;i++) {
52.     x=System.nanoTime();       
53.     if ( ( i % 1000000 ) == 0 ) print(".");
54.   }
55.   eend=millis();
56.   println("done");
57.   print("Testing hour() + second() + millis() starting!");   
58.   fstart=millis();
59.   for (int i=0;i<2147483646/100;i++) {
60.     x=hour() + second() + millis();       
61.     if ( ( i % 1000000 ) == 0 ) print(".");
62.   }
63.   fend=millis();
64.   println("done");
65.   print("Xor truly random starting!");  
66.   gstart=millis();
67.   for (int i=0;i<2147483646/100;i++) { 
68.     x=System.nanoTime();  
69.     x ^= (x << 21);
70.     x ^= (x >>> 35);
71.     x ^= (x << 4);   
72.     randomSeed(x); 
73.     int y=(int)random(0,100);
74.     if ( ( i % 1000000 ) == 0 ) print(".");
75.   }
76.   gend=millis(); 
77.   println("done");
78.   print("Xor cheat random starting!");
79.   x=System.nanoTime();    
80.   hstart=millis();
81.   for (int i=0;i<2147483646/100;i++) {     
82.     x ^= (x << 21);
83.     x ^= (x >>> 35);
84.     x ^= (x << 4);   
85.     randomSeed(x); 
86.     int y=(int)random(0,100);
87.     if ( ( i % 1000000 ) == 0 ) {
88.       print(".");
89.       x=System.nanoTime();
90.     }
91.   }
92.   hend=millis(); 
93.   println("done");
94. }
95. void draw() {
96.   println("Ready! The results are :");
97.   println("Xor fast random : "+(aend-astart)+ " millis");
98.   println("Processing nextInt random : "+(bend-bstart)+ " millis");
99.   println("Processing normal random : "+(cend-cstart)+ " millis");
100.   println("Java normal random : "+(dend-dstart)+ " millis"); 
101.   println("system.nanotime() : "+(eend-estart)+ " millis"); 
102.   println("hour() + second() + millis() : "+(fend-fstart)+ " millis");
103.   println("Xor truly random : "+(gend-gstart)+ " millis");
104.   println("Xor cheat random : "+(hend-hstart)+ " millis");
105. }

Hold on, calculating!
Xor fast random starting!......................done
Processing nextInt random starting!......................done
Processing normal random starting!......................done
Java normal random starting!......................done
Testing system.nanotime() starting!......................done
Testing hour() + second() + millis() starting!......................done
Xor truly random starting!......................done
Xor cheat random starting!......................done
Ready! The results are :
Xor fast random : 2038 millis
Processing nextInt random : 3056 millis
Processing normal random : 3094 millis
Java normal random : 3556 millis
system.nanotime() : 1135 millis
hour() + second() + millis() : 17731 millis
Xor truly random : 3175 millis
Xor cheat random : 1954 millis