Newsgroup: it.comp.lang.c
Titolo: quesito su random

Sera,
stavo tentando di creare un programmino che generi dei numeri
random...quindi sono andato sul sito che mi è stato consigliato l'altro
giorno per attingere quale funzione facesse al caso mio e ho trovato quanto
di seguito:
-----------------------
<stdlib.h>
RAND_MAX
    Maximum value returned by rand().
int rand(void);
    Returns pseudo-random number in range 0 to RAND_MAX.
void srand(unsigned int seed);
    Uses seed as seed for new sequence of pseudo-random numbers. Initial
seed is 1.
----------------------
okkio e croce questo è quello che fa per me!
E ho provato a scrivere una cosa del genere...in compilazione non genera
errore e mi da anche un valore 
2147483647
...ora non so se questo è il numero
random che trova, oppure un indirizzo di memoria...però non riesco come
passargli una limitazione...tipo trovami un random da 0 a 100!
E poi non capisco, ma ogni volta che lancio il programma..mi ridarà sempre
il solito valore? oppure si può ottenere un vero numero random! è per caso
srand? ma cosa significa quello tra parentesi!?
Comunque questo è il listato che ho provato...cosa mi potete dire?!
--------------------
#include<stdio.h>
#include<stdlib.h>
int main(void)
{
RAND_MAX;
int rand(void);
printf("%d questo è rand_max",RAND_MAX);
}
------------------------
grazie a tutti coloro che mi schiariranno le idee...e scusate se sono un po'
banale!!!
Byez
B@STIL@NI

}
Allora, vediamo di chiarire qualche dubbio.
1) la rand genera un numero casuale tra 0 e MAX_RAND. Se vuoi un
numero tra 0 e un qualche valore X devi semplicemente prendere il
risultato della rand() e calcolare l'operazione di modulo ("%") per
X+1.
2) se ti serve una generazione uniforme tra 0 e 1 devi dividere (non
il modulo) il risultato della rand() per RAND_MAX. Una volta che hai
questo valore puoi anche generare valori tra 0 e X moltiplicando il
risultato della rand()/RAND_MAX per X e poi arrotondando.
3) Il seme iniziale e' sempre uguale, e partento dallo stesso seme
generi SEMPRE la stessa sequenza di numeri (perche' la rand() non e'
casuale, ma solo pseudocasuale). Per rendere piu' casuale la sequenza
generata devi inizializzare il seed (seme) usando la srand()... devi
inizializzarlo a un valore qualsiasi, possibilmente non una potenza di
due. Un modo che ha discreto successo e':
<CODE>
srand(time(NULL));
</CODE>
-- 
Mox

 Mox
1000 grazie
byez
B@STIL@NI

time(NULL) che significa?
Guardi l'ora sull'orologio (la funzione time), non te la segni da
nessuna parte (il parametro a NULL), ma la passi alla funzione srand()
che provvedera' a inizializzare il seme (che e' una variabile
globale).
Chiaro? Se no rispiego :)
-- 
Mox

 Mox
grazie
byez
B@STI

 srand(time(NULL));
provato! :D non funge :(
//CODE
#include<stdio.h>
#include<stdlib.h>
int main(void)
{
int num;
num= srand(time(NULL)) % 10;
printf("%d questo S il numero casuale variabile",num);
}
//FINE CODE
mi dice:
"(6) Error: void value non ignored as it ought to be
There were some errors"
ma una volta inserito il srand(time(NULL)) non funziona come con rand
normale?!
thx
Byez
B@STI

provato! :D non funge :(
srand e rand non sono due funzioni analoghe come la printf e la
sprintf.
E' per quello che non funge. ;-)
Devi usare srand una volta all'inizio per scegliere il seed a partire
dal quale rand poi estrarrà i numeri casuali.
Prova come segue:
#include<stdio.h>
#include<stdlib.h>
int main(void)
{
  int num;
  srand(time(0));  /* prende time(0) e lo usa come seed (seme) */
  num = rand() % 10;  /* questo sceglie un numero casuale */
  printf("%d questo e' il numero casuale variabile", num);
 
  return 0; /* siccome il main e' un int, restituisce un valore  */
}

quindi genera un numero casuale a seconda dell'ora?!
Si, potresti anche leggere il valore da un dispositivo hardware il cui
indirizzo e' mappato in memoria e avresti un numero ancora piu'
casuale del tempo, ma non e' cosi' facile come leggere l'ora.
-- 
Mox

}
-- 
Mox

 ------------------------
Posso dire che non compila. 
#include <stdlib.h>
#include <stdio.h>
int main() {
	printf("questo e` rand_max: %d\n", RAND_MAX);
	printf("questo e` un numero casuale: %d\n", rand());
	return 0;
}
I numeri  sono pseudocasuali,  e cioe`  sono calcolati  a partire  da un
valore iniziale. Se non specifichi il valore iniziale, esso verra` posto
a  1  e  la  sequenza  sara`  sempre  la  stessa. Per  inizializzare  il
generatore si usa srand:
void srand(unsigned int seed);
E` pratica comune  inizializzare il generatore con il timer,  in modo da
avere delle serie  diverse di esecuzione in esecuzione  (posto che siano
separate da almeno un secondo):
srand((unsigned int)time(NULL));
Per ottenere un numero da 0 a 100:
n = (int)(100.0 * rand() / RAND_MAX);
non qualcosa del tipo:
n = rand() % 100;
ciao
Kronos
-- 
Home: 
http://kronoz.cjb.net
"Woe to you, Oh Earth and Sea,
 for the Devil sends out the beast with wrath,
 because he knows the time is short...
 Let him who had understanding reckon the number of the beast
 for it is a human number, its number is Six hundred and sixty six."
Revelations ch XIII, b. 18

n = rand() % 100;
Il risultato e' piu' o meno simile (non dirlo al mio prof di
statistica pero' :P).
C'e' una differenza pero': con il tuo metodo Kronos generi una
distribuzione uniforme da 0 a 1 e poi moltiplichi per 100 al fine di
ottenere numeri da 0 a 100.
Il mio e' piu' grezzo e ottiene un risultato molto simile dal lato
pratico, ma in effetti tutti i numeri che genero non sono
equiprobabili (o meglio, potrebbero non esserlo, ma questo dipende da
per che valore eseguo il modulo e qual'e' il valore di RAND_MAX).
Spero mi riconoscerai che questa differenza, seppure non sia una
distribuzione uniforme, per lo meno le si avvicina parecchio :).
Nota: hai commesso una piccola imprecisione (nella fretta immagino):
per ottenere numeri da 0 a 100 devi fare il modulo per 101, non per
100 :)
-- 
Mox

 n = rand() % 100;
ecco...appunto preciso preciso come l'ho utilizzato io :P
l'errore a cui si riferiva Mox del 101....lo devo applicare anche in
100.0*rand?
thx
byez
B@STI

100.0*rand?
No, solo se usi il modulo.
-- 
Mox

1000 grazie a tutti coloro che mi hanno aiutato! :D
Byez
B@STI

"Mox" ha scritto
: >
: >n = (int)(100.0 * rand() / RAND_MAX);
: >
: >n = rand() % 100;
:
: Il risultato e' piu' o meno simile (non dirlo al mio prof di
: statistica pero' :P).
: C'e' una differenza pero': con il tuo metodo Kronos generi una
: distribuzione uniforme da 0 a 1 e poi moltiplichi per 100 al fine di
: ottenere numeri da 0 a 100.
C'e` una differenza piu` evidente:
con la divisione (cosi` come e` scritta) i numeri da 0 a 99 compreso
compaiono con frequenza circa 1/100 mentre 100 esce con frequenza
1/RAND_MAX [*].
con il modulo escono solo i numeri da 0 a 99 compreso [0,99]
: Il mio e' piu' grezzo e ottiene un risultato molto simile dal lato
: pratico, ma in effetti tutti i numeri che genero non sono
: equiprobabili (o meglio, potrebbero non esserlo, ma questo dipende da
: per che valore eseguo il modulo e qual'e' il valore di RAND_MAX).
I numeri non sarebbero equiprobabili neanche con la divisione, l'unica
differenza e` che con il modulo quelli un po` piu` probabili sono sempre
i piu` piccoli.
[*] Provare per credere (ho sostituito 10 a 100 per fare stare l'output
    in una schermata):
#include <stdlib.h>
#include <stdio.h>
#define DIECI 10
int main()
{
  int j,i, estrazioni[DIECI+1];
  printf( "Formula n = (int)(10.0 * rand() / RAND_MAX);\n" );
  srand(0);
  for ( j=0; j<DIECI+1; ++j ) estrazioni[j] = 0 ;
  for ( j=0; j<RAND_MAX; ++j ) for ( i= 0; i < 10; ++i ) {
    int n = (int) (10.0 * rand() / RAND_MAX);
    estrazioni[ n ]++;
  }
  for ( j=0; j<DIECI + 1; ++j )
    printf("%d e` uscito - %d volte\n", j, estrazioni[j] );
  printf( "Formula n = rand() % 10;\n" );
  srand(0);
  for ( j=0; j<DIECI+1; ++j ) estrazioni[j] = 0 ;
  for ( j=0; j<RAND_MAX; ++j ) for ( i= 0; i < 10; ++i ) {
    int n = rand() % 10;
    estrazioni[ n ]++;
  }
  for ( j=0; j<DIECI + 1; ++j )
    printf("%d e` uscito - %d volte\n", j, estrazioni[j] );
  getchar();
  return 0;
}
ciao
Massimo

i piu` piccoli.
Gia', questo e' il problema, la distribuzione di probabilita' si
sposta verso il basso, anche se non e' poi cosi' percettibile questa
differenza.
-- 
Mox