Newsgroup: it.comp.lang.c
Titolo: Problema di tempo!!!

salve a tutti!
Ho la necessità di sviluppare una grande quantità di numeri casuali tutti
diversi tra loro...
per il momento uso srand((unsigned int))time(NULL)) e poi con rand creo il
valore.
Così ho sempre numeri freschi, però il problema è che hanno un tempo di vita
di UN SECONDO sotto linux mandrake.
Un secondo per me è davvero troppo... come posso fare a diminuire questo
tempo fino al minimo?
non è che per caso linux conta un secondo alla volta?
grazie e ciao,
mmarko.
--
Rimuovi NOSPAM per rispondere in privato

 diversi tra loro...
Ops, :-) domanda già postata poco tempo fa, però non ancora risolta! vabbè,
chi risponderà vorrà dire che aiuterà due piccioni con una fava :-)


 valore.
Gravissimo errore, ma non sei il primo che ci casca.
srand() si una una volta sola PRIMA di generare i numeri casuali, dopo usi 
solo piu' rand().
-- 
Mox
"Trust the programmer."
"Don't prevent the programmer from doing what needs to be done."
"Keep the language small and simple."
"Provide only one way to do an operation."


Tranquillo non ci sono cascato :-)
dal mio post si capisce poco, cmq uso srand per inizializzare il valore e
rand per crearlo di volta in volta.
Ma il problema rimane, me ne crea uno al secondo...
Mentre per l'applicazione che sto creando me ne servono diverse MIGLIAIA al
secondo, non so se intuisci che tipo di applicazione sto cercando di fare
:-)
hai la soluzione?


 :-)
Boh, io ne genero mediamente 2 milioni in un secondo usando un Athlon XP con 
una SuSE 8 (con un programmino scemo che genera numeri casuali finche' il 
timer non arriva a 1 secondo, calcolando il tempo in modo CPU intensive, 
cosa molto costosa).


 cosa molto costosa).
ehm... e con rand e srand cosa dovrei fare?
hai per caso i sorgenti di quel programmino per vedere se la funzione è
facilmente implementabile?
grazie e ciao,


 secondo, non so se intuisci che tipo di applicazione sto cercando di fare
Non si continua a capire quale e' il tuo problema.
All'inizio del programma esegui 1 volta soltanto la srand(time(NULL)).
Poi nel resto del programma puoi invocare quante volte vuoi la rand
ottenendo sempre numeri casuali.
cioe', per averene 1000 fai:
srand(time(NULL));
for (i=0; i<1000; i++) MioArray[i]=rand();
e ogni invocazione di rand() produce un numero casuale e ci
mette molto meno di 1 secondo !
Spiegati meglio !
Se poi il tuo problema e' che invochi il programma piu' volte in un 
secondo, allora il problema e' diverso, perche'
effettivamente i diversi programmi invocati avrebbero lo stesso punto
di partenza.
Io un problema simile l'ho risolto sotto linux leggendo dei bytes che
uso poi per generare il seme, dal file (finto) /dev/urandom o
/dev/random che essendo (piu' o meno) lo stream di numeri casuali usati 
dal kernel, non dipende da time(). Fai un bel man urandom per vedere
di cosa si tratta.
Inoltre nel tuo post affermi che vuoi i valori casuali tutti diversi.
Attenzione ! Se questo e' vero, allora i tuoi numeri non sono veramente
casuali. Cioe', in una vera sequenza casuale (per esempio generata con 
rand()) dovresti avere anche dei numeri ripetuti.
ciao,
g.

 mette molto meno di 1 secondo !
Per 1000 num. nessun problema, ma c'è da dire che da un certo
punto in poi, i numeri tirati fuori da rand si ripeteranno; anche se dopo
una serie mooooolto lunga!
quindi magari ogni 3-4k numeri lo rifarei srand...
Ph.


A meno di non considerare una versione di rand vecchia (quella con 
RAND_MAX = 32767 e i bit bassi poco random) tutti i generatori standard
tipo random() e lrand48() recenti
hanno un periodo superiore a 2^30, cioe' il ciclo ricomincia dopo piu'
di un miliardo di estrazioni.
Quindi ripetere uno srand() ogni 4000 numeri e' matematicamente inutile,
oltre ad essere rischioso se si usa srand(time(NULL)) che se invocato
nello stesso secondo produrra' come si e' detto la stessa sequenza.
ciao,
g.

 �facilmente implementabile? grazie e ciao,
Questa funzione statisticamente fa pena, guarda sulle FAQ di comp.lang.c per 
una trattazione un po' piu' completa sulla generazione di numeri piu' 
pseudocasuali senza togliersi dalla funzione rand.
Te lo riscrivo al volo, i sorgenti li ho cancellati dopo l'uso... l'ho 
provato in fretta e pare funzionare: lavora per circa un secondo e genera 
numeri casuali per tutto il tempo (quando non e' impegnato a fare il 
*costosissimo* costo del tempo trascorso, cosa che simula una discreta 
attivita').
<code>
#include <time.h>
#include <stdio.h>
#include <stdlib.h>
int main() {
    clock_t t1, t2;
    double c = 0.0;
    srand((unsigned)time(NULL));
    t1 = clock();
    while ((clock() - (double)t1) / CLOCKS_PER_SEC < 1.0) {
        /*
         * simula un pessimo generatore con un numero di cui non si
         * calcoli facilmente il modulo (non una potenza di 2 quindi)
         */
        rand() % 13;
        /* incrementa il contatore */
        c++;
    }
    printf("Numeri casuali generati: %lf\n", c);
    return EXIT_SUCCESS;
}
</code>


 provato in fretta e pare funzionare: lavora per circa un secondo e genera
... CUT
Ti ringrazio tanto, appena ho tempo lo provo e ti faccio sapere!
