Newsgroup: it.comp.java
Titolo: quant'è random la classe random di java?

ciao a tutti,
Ho provato a far girare un programma che provasse a darmi valori
random ma non mi pare che siano proprio tutti casuali... A voi è
capitata una cosa del genere? O avete usato qualche classe trovata in
rete? Se si me ne consigliate qualcuna buona?
Grazie
ciao


Rispondo solo a questo di messaggio :)
Per la sua stessa natura, una macchina non puo' generare dei numeri a 
random, bensi' "pseudocasuali". Infatti due istanze della classe Random 
ritornano la stessa sequenza di numeri, se istanziate con lo stesso seme.
Ti consiglio quindi di usare ogni volta un seme diverso, che puo' essere 
per esempio Date().getTime()

 per esempio Date().getTime()
Che intendi per seme? Non sono troppo pratica... mi potresti fare un
esempio di come usarlo? Cmq grazie lo stesso!

 esempio di come usarlo? Cmq grazie lo stesso!
Guarda il costruttore di Random
public Random(long seed)
Creates a new random number generator using a single long seed 
Seed=seme ;)
Come ti diceva Giambo, se istanzi due random con lo stesso seme, ti produrranno sempre la stessa sequenza di valori. L'unico modo per ottenere la pseudo casualita' e' utilizzare di volta in volta semi diversi e un valore tipicamente usato e' l'orario... poi, che tu usi Date().getTime() o System.currentTimeMillis() e' irrilevante ai fini del risultato!!
Saluti
CarMas

 CarMas
Se non avevo letto male in giro quando non scrivo nulla nel
costruttore di  Random mette di default System.currentTimeMillis(),
quindi in teoria non dovrei scrivere nulla in più... cmq ho fatto
delle prove e sembrerebbe funzionare!


Forse sbagliavi usando sempre lo stesso oggetto senza reinstanziarlo.

C'è una cosa che ancora non ho capito bene... vengono calcolati anche
gli estremi quando richiamo nextDouble() ? Quando uso nextInt()
l'estremo superiore non viene estratto, ma con i double?  Qual'è
inoltre la differenza con Math.random? Sembra che dia lo stesso
risultato di nextInt()... qual'è meglio usare?
grazie

 delle prove e sembrerebbe funzionare!
Non sono proprio praticissimo ma - andando a spanne - se fai una cosa tipo:
for (int i=0; i<100; i++)
{
   Random r = new Random();
   System.out.printl(r.next());
}
è probabile che il valore di millisecondi utilizzato per le diverse 
instanziazioni sia lo stesso e quindi anche la generazione psudocasuale 
darà lo stesso risultato.
Potresti postare un piccolo esempio di codice?
Ciao,
Giulio
--
OnAir: Blind Guardian - "The Wizard"


ho voluto fare una prova di quanto la classe fosse veramente random...
praticamente ho fatto calcolare 100.000 valori a caso tra 1 e 10e10 e
ho notato che, andando a fare un istogramma, le colonne sono quasi
tutte alla stessa altezza... oscillano di 100 o 200 conteggi max.
Quello che mi chiedo io è: dovrebbe aversi una distribuzione uniforme
(e quindi TUTTO uguale) oppure queste oscillazioni sono più che
normali? Il codice è questo:
	Random rand = new Random();
		int total=100000;
		FileOutputStream File = new FileOutputStream("/prova/random1.dat");
		PrintStream Output = new PrintStream(File);
		for (int i = 0; i < total; i++) {
			Output.printf("%.15e ",Math.pow(10, 10.11 * rand.nextDouble()));
			Output.println();
		}
		Output.close();
		double[] age = new double[total];
		Scanner line = new Scanner(new File("/prova/random1.dat"));
		for (int i = 0; i < total; i++) {
			age[i] = Double.parseDouble(line.next());
		}
		double a[] = new double[12];
		double hist[] = new double[a.length];
		a[0] = 1.;
		for (int i = 1; i < a.length; i++)
			a[i] = a[i - 1] * 10;
		for (int k = 0; k < total; k++) {
                        //creo l'istogramma
			double Age = age[k];
			for (int i = 0; i < a.length - 1; i++) {
				if (Age > a[i] && Age <= a[i + 1])
					hist[i] = hist[i] + 1;
			}
		}
		FileOutputStream Filea = new FileOutputStream("/prova/random2.dat");
		PrintStream Outputa = new PrintStream(Filea);
		Outputa.printf("%.15e     %.15e ", 0., 0.);
		Outputa.println();
		for (int j = 0; j < a.length; j++) {
			Outputa.printf("%.15e     %.15e ", a[j], hist[j]);
			Outputa.println();
		}
		Outputa.close();
Se vado a vedere il file generato i valori sembrano essere tutti
diversi, ma valli a controllare tutti e 100.000! Per questo ho poi
usato gnuplot per visualizzare l'istogramma.

 writes:
A> C'è una cosa che ancora non ho capito bene... vengono calcolati
A> anche gli estremi quando richiamo nextDouble() ? Quando uso
A> nextInt() l'estremo superiore non viene estratto, ma con i double?
É la stessa cosa.
A> Qual'è inoltre la differenza con Math.random? Sembra che dia lo
A> stesso risultato di nextInt()... qual'è meglio usare?
Credo  che  Math.random  abbia  già  pronto qualcosa  per  gestire  la
concorrenza. Ma direi che USA Random.nextDouble.
-- 
 /\           ___
/___/\_|_|\_|__|___Gian Uberto Lauri_____
  //--\| | \|  |   Integralista GNUslamico
\/                 e coltivatore diretto di Software
A Cesare avrei detto di scrivermi a 
fn...@rat.vg
P.S.
Leggersi il capitolo del Knuth citato nei JavaDoc di Random rivela
simpatiche sorprese, olte ad essere *MOLTO* istruttivo.

 simpatiche sorprese, olte ad essere *MOLTO* istruttivo.
Magari lunedì... il venerdì pomeriggio è impossibile da me trovare la
biblioteca aperta! :-)