Newsgroup: it.comp.lang.c
Titolo: Problemi col generatore

Ho letto tutti i messaggi e ho scritto la mia funzione random per
generare numeri con una distribuzione uniforme.
Ho impostato il seed co l orario del computer ma in pratica accade che:
1. i numeri casuali vengono fuori in ordine crescente
2. se compilo il programma nello stesso MINUTO ho lo stesso numero
casuale..
sapete illuminarmi?

sas...@gmail.com
 wrote:

io non so che mesaggi hai letto.
se non fai vedere il codice, come pretendi che ti si possa aiutare ?
la generazione di numeri uniformi richiede una riga di codice
e una conoscenza veramente minima del C.
Per iniziare mostra almeno le righe di codice dove fai l'inizializzazione,
dove estrai il numero e dove lo usi.
ti sei ricordato di includere time.h e stdlib.h ?
hai inizializzato il seme cauale UNA SOLA VOLTA all'inizio del programma ?
con qualcosa come
srand(time(0)); ?
il "difetto" di time(0) e' che restituisce il numero di secondi dal
1/1/1970, quindi se *esegui* il programma due volte nello stesso
secondo ti verra' lo stesso seme iniziale, ma non riesco
proprio a capire come possa centrare il tempo di *compilazione* ??
fai veder il codice... e magari dicci anche che sistema operativo e che
compilatore usi, tanto per scaramanzia....
ciao,
g.

vanvera wrote:
scusate gli eerroti ortografici, ho scritto troppo infreta,
e ho un po'' di tasti del portatite che mi fanno cilecca alla prima....
ciao,g

#include <stdlib.h>
#include<stdio.h>
#include<time.h>
main(){
int a,b,c;
a=10;
b=210;
srand((unsigned)time(NULL));
double rnd = (double)rand() / (double)(RAND_MAX+1);
c= rnd *(b-a) + a;
printf("il numero è: %d",c);
system("pause");
}
come vedi è tutto in ordine,il compilatore è lcc-win32 e il sistema
operativo l xp2000-he



 }
Non e' proprio tutto in ordine...
a parte che andrebbe scritto int main()...
e che ci vorrebbe un return 0; alla fine,
penso che l'errore (almeno e' tale sul mio compilatore)
potrebbe essere in quel
(double)(RAND_MAX+1);
il problema potrebbe essere che RAND_MAX e' gia' uguale al massimo
intero rappresentabile quindi non puoi aggiungergli un 1 impunemente
senza avere un overflow degli interi.
(cosa che, se questo e' il caso, il compilatore dovrebbe segnalarti
se compili con lo switch -Wall)
per evitare overflow interi (se questo e' il problema) e' meglio se
scrivi
double rnd = rand() / (RAND_MAX+1.0);
quando il complilatore vede +1.0 "promuove" automaticamente RAND_MAX a
double e fa lo stesso con il risultato di rand() etc.etc.
l'ultima cosa: sicuramente lo sai, ma tieni conto
che con quel sistema generi numeri compresi
tra a e b-1 (estremi inclusi) e non tra a e b (estremi inclusi),
perche' la conversione automatica dell'espressione rnd*(b-a)+a da double
a int comporta troncamento. quindi nel caso tu volessi numeri tra a e b
estremi inclusi devi fare una cosa tipo a+rnd*(b-a+1).
ciao,
g.

GRAZIE MILLE PURTROPPO PERò NN HO RISOLTO! :-(

 }
Gli errori te li hanno gia' fatti notare.
Se vuoi, prova questa versione:
=======
#include <stdlib.h>
#include <stdio.h>
#include <time.h>
/* questa #define e' su 2 linee, attenzione al copia/incolla! */
#define RANDOM_CALC(nRand, nMin, nMax, nRandMax) \
     ((nMin) + (long)((double) ((nMax) - (nMin) + 1.0) * ((nRand) / 
((nRandMax) + 1.0))))
int main(void)
{
         int i;
         int nMin = 10,
             nMax = 210;
	int nGen = 20;
         srand(time(NULL));
         for(i = 0; i < nGen; i++)
         {       long lRand = (long)rand();
                 lRand = RANDOM_CALC(lRand, nMin, nMax, RAND_MAX);
                 printf("%ld\n", lRand);
         }
         return(0);
}
=======
Ciao
-- 
Cybertoldo
Per rispondermi via email, sostituisci moc.liamg con 
gmail.com

Grazie!ho preso la tua funzione e anzichè inizializzare con
l'orario(fatto che mi dava problemi)inizializzo io la srand().
Non per approfittarne,ma come avrai capito sono alle prime armi...
Sai come si generano i random anzichè in una uniforme in una
distribuzione normale???
Grazie mille

 Grazie mille
Un semplice algoritmo potrebbe essere questo:
http://www.taygeta.com/random/gaussian.html
(lo riporto sotto; la funz. intatta, copyright dell'autore, e codice di 
test)
~~~~~~~ file: boxmuller.c ~~~~~~~~~~~~~~~~~~~~~~~~~~~~
/* gcc -o boxmuller boxmuller.c -lm */
#include <stdio.h>
#include <stdlib.h>
#include <time.h>
#include <math.h>
double ranf(void)
{	return (rand() / (RAND_MAX + 1.0));
}
/*-------------------------------------------
   boxmuller.c		Implements the Polar form of the Box-Muller
			Transformation
		    (c) Copyright 1994, Everett F. Carter Jr.
			Permission is granted by the author to use
			this software for any application provided this
			copyright notice is preserved.
*/
float box_muller(float m, float s) /* normal random variate generator */
{                                  /* mean m, standard deviation s */
    float x1, x2, w, y1;
    static float y2;
    static int use_last = 0;
    if (use_last) {                 /* use value from previous call */
       y1 = y2;
       use_last = 0;
    } else {
       do {
          x1 = 2.0 * ranf() - 1.0;
          x2 = 2.0 * ranf() - 1.0;
          w = x1 * x1 + x2 * x2;
       } while ( w >= 1.0 );
       w = sqrt( (-2.0 * log( w ) ) / w );
       y1 = x1 * w;
       y2 = x2 * w;
       use_last = 1;
    }
    return( m + y1*s );
}
/*-----------------------------------------*/
int main(void)
{	int i;
	int nGen = 100;
	srand(time(NULL));
	for(i = 0; i < nGen; i++)
	{	double r = box_muller(.0, 1.0);
		printf("%f\n", r);
	}
	return (0);
}
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~


Grazie mille!!!

Grazie mille!!!

 unitaria.
se non ricordo male:
(x - valore_atteso[x]) / sqrt(varianza[x])
Ciao

 Bisogna fare dei calcoli, non ricordo quali :-)
ricordo che quando c'era da calcolare la varianza di N v.c. bisognava 
tenere conto della coviarianza, tipo qualcosa come:
var[somme_da_1_N Xi] = somme_da_1_N (var[Xi]) + somme_da_1_N 
(somme_da_1_N(covarianza[Xi,Xj]))
con i!=j
si risolveva invece come somma di varianze quando c'era indipendenza tra 
le v.casuali, per cui la covarianza era 0 ;)
Ciao