Newsgroup: it.comp.lang.c
Titolo: Codice per simulare un problema matematico

In un ng è stato chiesto di risolvere il problemino che posto qui sotto.
A me interessa (per altri motivi) scrivere il codice per simulare il 
problema generando numeri casuali per far capitare a caso una malattia e 
il relativo sintomo. Ripetendo milioni di volte la simulazione, dovrei 
ottenere la probabilità cercata.
Il programmino dovrebbe essere molto banale, ma il risultato non mi 
viene uguale a quello ottenuto matematicamente. Vorrei chiedere se per 
cortesia qualcuno può postare il codice per simulare questo problema:
 
Tre malattie A, B e C causano un certo sintomo con probabilità Fa= 0,9, 
Fb= 0,6 e Fc= 0,4. Un individuo è affetto da ciascuna malattia con 
probabilità Pa= 0,1%, Pb= 1% e Pc= 5%. E' possibile avere solo una 
malattia per volta e in assenza di una malattia non si ha alcun sintomo.
Sapendo che un paziente presenta il sintomo, qual'è la probabilità che 
egli abbia la malattia B?
 
Grazie
Cristiano


Suppongo che il sintomo non sia "relativo ad ognuna", ma lo stesso per tutte
le malattie, altrimenti la domanda non ha molto senso. Penso sia questo quello
che chiedevi ma il primo paragrafo era un po' sibillino.
 
Scrivere la simulazione è più difficile che fare il calcolo, direi.
 
Come prima cosa, prendi N individui (per come dimesionare i valori che 
scegliamo lo vediamo alla fine). Per ciascuno assegni la malattia A, B o C
in base alla probabilità. Per ogni individuo malato assegni poi se ci sono
i sintomi o no, sempre in base alla probabilità.
 
#define PROB_DISA 0.9
#define PROB_DISB 0.6
#define PROB_DISC 0.4
#define PROB_SYNA (0.1/100)
#define PROB_SYNB (1/100)
#define PROB_SYNC (5/100)
 
#define DIS_A 0x01
#define DIS_B 0x02
#define DIS_C 0x04
#define SYN   0x08
 
int people[N];
 
/* ritorna un valore tra 0 e 1 random, scegli un po' te come.. */
double getRand(void);
 
double sym(void) {
    int i;
    int nSyn, nB;
    /* assegnamo le malattie */
    for (i=0; i<N; ++i)
        if (getRand()<PROB_DISA) people[i] |= DIS_A;
        else if (getRand()<PROB_DISB) people[i] |= DIS_B;
        else if (getRand()<PROB_DISC) people[i] |= DIS_C;
    /* assegnamo i sintomi */
    for (i=0; i<N; ++i)
        if (people[i]&DIS_A && getRand()<PROB_SYNA) people[i] |= SYN;
        else if (people[i]&DIS_B && getRand()<PROB_SYNB) people[i] |= SYN;
        else if (people[i]&DIS_C && getRand()<PROB_SYNC) people[i] |= SYN;
    /* adesso abbiamo tutti i dati..
       la probabilità cercata è tutti quelli che non hanno il sintomo su quelli
       che hanno la malattia B. */
    for (i=nSyn=nB=0; i<N; ++i) {
        if (people[i]&DIS_B) ++nB;
        if (people[i]&SYN) ++nSyn;
    }
    return nSyn/nB;
}
 
a questo punto questa funzione la puoi chiamare come necessario, probabilmente
vorrai fare una media, ma chissà.
 
Per come dimensionare i valori e quale generatore random chiamare è tutta una
discussione che lasciamo stare, per cui se non devi trovare risultati precisi
metti N a 10000, fai 100000 iterazioni e usa il generatore standard :-)
 
Ciao!

 e usa il generatore standard :-)
 
Giammai! :-)
 
Ciao
Cristiano

 
 
Ho sbagliato così tanto? :) Adesso ci penso un altro po' e lo riscrivo allora
;)
 
Ciao!

 Adesso ci penso un altro po' e lo riscrivo allora ;)
 
Ok. Credo che non avrai difficoltà ad eliminare l'enorme vettore 
"people". :-)
 
Riporto il codice che ho scritto io e mi scuso subito per non essere 
proprio in C:
 
    const int NT= 1000000;
    int cb= 0;
    for(int V= 0; V < NT; ) {
       int a= 0, b= 0, c= 0; // Malattie
       int pre= 0; // Sintomo non presente
 
       if(RNDuni() < .001) { // A
          a= 1; if(RNDuni() < .9) pre= 1;
       }
       if(RNDuni() < .01 ) { // B
          b= 1; if(RNDuni() < .6) pre= 1;
       }
       if(RNDuni() < .05 ) { // C
          c= 1; if(RNDuni() < .4) pre= 1;
       }
 
       if(pre) {
          if(a + b + c == 1) { // Solo 1 malattia per volta
             V++; // Caso valido (Presenza sintomo e solo 1 malattia)
             if(b) cb++;
          }
       }
    }
    printf("%d  %g\n", cb, cb / double(NT));
 
Cristiano

 proprio in C:
 
Perché non usi octave oppure R? Mi sembrano adatti allo scopo e in 
genere sono ottimizzati con ATLAS (anche se in questo caso non mi pare 
ci sia molta algebra).

 ci sia molta algebra).
 
Dovrei imparare ad usarli. Inoltre, un programma che scrivo io lo posso 
ottimizzare e velocizzare a piacimento (ad esempio con il multi-thread 
di vario genere).
 
Cristiano
 

 egli abbia la malattia B?
 
Che cavolo c'entra col C?

 e non simulati. Bah! Idiozia della scuola moderna.
 
mah per esercizio si puo' fare :)
inoltre ci sono cose che non siamo in grado di risolvere analiticamente:
la simulazione e' l'unica strada percorribile.
 
Ciao Jack
-- 
Yoda of Borg am I! Assimilated shall you be! Futile resistance is, hmm?

 di vario genere).
 
LOL.
Prima di pensare all'ottimizzazione fossi in te inizierei a scrivere del
codice funzionante.
Inoltre in generale per ottimizzare, prima bisogna sapere la teoria
dell'algoritmo che si vuole ottimizzare.
 
Vai a studiare un po' di probabilita' e sttistica, poi in caso torni e
ti aiutiamo a scrivere il programma, se hai problemi con il C.


 ti aiutiamo a scrivere il programma, se hai problemi con il C.
 
Per fortuna non sono tutti cafoni come te!
 
Plonk
Cristiano
 

 
 
"Tagliando" tutta la simulazione e lasciando solo il number crunching allora
abbiamo:
 
double sym(void) {
    int i;
    double nSyn=0, nB=0;
    for (i=0; i<N; ++i) {
        if (getRand()<PROB_DISA && getRand()<PROB_SYNA) ++nSyn;
        else if (getRand()<PROB_DISB) {
            ++nB;
            if (getRand()<PROB_SYNB) ++nSyn;
        }
        else if (getRand()<PROB_DISC && getRand()<PROB_SYNC) ++nSyn;
    }
    return nB/nSyn;
}
 
Che comunque da ~0.37.
 
La cosa che non mi torna, e dove probabilmente sbagliamo, è come prendiamo
gli eventi.
Ogni volta che facciamo un getRand() (o RNDuni()) siamo su un nuovo evento,
ma probabilmente non è questo che bisogna fare.
Ci devo pensare un altro po' ;)
 
Ciao!

 Cristiano
 
eh plonkami, intanto ti do' un aiuto. Devi fare questo:
http://it.wikipedia.org/wiki/Probabilità_condizionata



Non per dire eh, ma l'OP il risultato numerico l'ha già calcolato e ce l'ha
pure detto.
Ha chiesto una mano con un codice che ha pure postato.
Quindi boh, non vedo perché fare così una volta che qualcuno posta un problema
un po' diverso dal solito.
Potresti dare una mano, invece.
 
Ciao!

 Potresti dare una mano, invece.
 
quando (se) avra' un problema col in C saro' felicissimo di auitarlo se
ne sono in grado.
Finche' ha problemi con l'algoritmo perche' non ha idea di quello che
sta facendo...


 la simulazione e' l'unica strada percorribile.
 
Che cosa c'entra nel caso in questione? Si tratta di un banale esercizio 
di simulazione, basta cercare e si trovano già risolti, tu parli di Metodi
Montecarlo. Mi pare che stai esagerando un poco. E forse anche io a 
continuare la discussione.

 Ci devo pensare un altro po' ;)
 
Non c'è fretta. :-)
Tanto devo consegnare il compitino dopo le vacanze, ROTFL! Così è 
contento anche quell'altro troll dei compiti a casa (l'ultima volta che 
ho messo piede in una scuola deve essere stato circa 35 anni fa).
 
Ciao e grazie
Cristiano

 Potresti dare una mano, invece.
 
Ti ringrazio per il fatto di sostenere la mia richiesta, ma di fronte a 
certi comportamenti puramente polemici e trollosi conviene, a parer mio, 
ignorare e/o plonkare.
 
Cristiano

 Che cosa c'entra nel caso in questione? Si tratta di un banale esercizio
 
niente, io rispondevo alla frase di neonano.


 completamente nella simulazione.
 
Questo perche' il problema non e' nel codice, e' in quello che vuoi far
fare al codice.


 diverso dal solito.
 
Non mi pare che L'OP appia postato codice non tuo. 
 
Non mi pare nè che il problema postato riguardi il C, anzi l'OP ha proprio 
detto che ha copiato da un altro gruppo, nè che questo gruppo abbia le 
competenze per rispondere. *
 
E per dirla tutta i metodi per fare queste simulazioni sono standard ma non
mi pare che nessuno li abbia applicati. E per i numeri dati, si ecco, sono
numeri buono per essere giocati al lotto dopo una rinormalizzazione ma non
significativi come risultato di una simulazione. 
 
 
 
 

 significativi come risultato di una simulazione.
 
Sono sicuro che è come dici te. Ma allora perché non dai qualche dettaglio
in merito? Io non ne ho idea ma, anche senza dare una soluzione o una sola
riga di codice, potresti scrivere una risposta tipo: "di solito questi
problemi si risolvono con i software XX che utilizzano il metodo YY; se ci
vuoi provare in questo modo non può funzionare per il motivo ZZ."
 
Voglio dire.. alla fine se, a quanto dite, tutti sanno come funziona tranne
l'OP e me, che sono l'unico che prova a risolvere, non andiamo da nessuna
parte.
Io, sinceramente, non ho voglia di mettermi a studiare il problema nei dettagli
(indipendentemente dal fatto che magari l'OP lo debba fare) perché ho altro
da fare e la cosa m'interessa il giusto, ma aiutare i curiosi (anche di
chi leggerà questo 3D in futuro) non è che fa male, eh.
 
Ciao!

 
 
Il delta che hai scritto non è molto, magari è solo una sottigliezza o qualche
errore in virgola mobile..
Se posti il nuovo magari ti si da un parere!
 
Ciao!

 errore di concetto nel codice.
 
cito il primo post dell'OP:
"Il programmino dovrebbe essere molto banale, ma il risultato non mi 
viene uguale a quello ottenuto matematicamente. Vorrei chiedere se per 
cortesia qualcuno può postare il codice per simulare questo
problema:..."
 
Se avesse postato il codice (e magari anche l'algoritmo in pseudocodice,
giusto per sapere cosa dovrebbe fare il codice), penso che nessuno
avrebbe avuto problemi ad aiutarlo.
Ma non l'ha fatto, ha aspettato che tu postassi qualcosa.
Inoltre sta andando a tentativi, non ha idea di quello che sta facendo e
neanche del perche' lo sta facendo. Insomma qua il problma e' tutto
tranne che il codice.


 Se posti il nuovo magari ti si da un parere!
 
Il "nuovo" è quello che ho postato il 15 alle 20:39; lo ri-posto:
 
    const int NT= 1000000;
    int cb= 0;
    for(int V= 0; V < NT; ) {
       int a= 0, b= 0, c= 0; // Malattie
       int pre= 0; // Sintomo non presente
 
       if(RNDuni() < .001) { // A
          a= 1; if(RNDuni() < .9) pre= 1;
       }
       if(RNDuni() < .01 ) { // B
          b= 1; if(RNDuni() < .6) pre= 1;
       }
       if(RNDuni() < .05 ) { // C
          c= 1; if(RNDuni() < .4) pre= 1;
       }
 
       if(pre) {
          if(a + b + c == 1) { // Solo 1 malattia per volta
             V++; // Caso valido (Presenza sintomo e solo 1 malattia)
             if(b) cb++;
          }
       }
    }
    printf("%d  %g\n", cb, cb / double(NT));
 
Come vedi, ho voluto tenere gli eventi indipendenti (senza if in 
cascata); quando capitano le condizioni imposte (presenza di sintomo e 
solo 1 malattia), il codice accumula i conteggi.
Mi sembra che simuli esattamente il problema, invece... :-(
 
Cristiano

 parte.
 
Io scrivo simulazioni di Monte Carlo a getto continuo, per cui, tra le 
tante che ho scritto, m'interessava scrivere pure questa simulazione, ma 
non pensavo che avrei attirato tutti 'sti troll incompetenti!
 
Bene, fine di questa parte del discorso (mi sono rotto le scatole a 
sufficienza).
 
Cristiano

 Io scrivo simulazioni di Monte Carlo a getto continuo, per cui, tra le
 
non sembra a vedere l'algoritmo che usi per "risolvere" il problema.


 ...
 
MADONNA MIA AIUTACI TU.	
 
il problema qui non è il linguaggio C (nè MATLAB o R o qualsiasi 
altro linguaggio), qui il problema è che sia l'OP sia  Massei non 
capiscono una cippa di cazzo sulla statistica o sulla teoria delle 
probabilità. Scusate il francesismo. 
 
Qui l'unica cosa da fare è impostare il follow-up sul newsgroup che 
ha originato la questione, e l'avrei già fatto se l'OP, da scostumato 
qual è, avesse detto da quale gruppo proviene.
 
Non essendo possibile mi tiro fuori, lascio che i troll si scannino 
tra loro plonk
 
 
 

 
 
Non ci voleva molto a capirlo, bastava chiedere.
 
Detto questo, fatto sta che (ed ho seria difficoltà a scriverlo senza
insultare) nessuno ha postato *nulla*.
 
Quindi sì, sulla fiducia bravi tutti a parte noi due: contento?
 
Ciao!

 corretto sembrerebbe 0,223.
 
Probabilita' di avere il sintomo S se hai A.
P(S|A) = 0.9
 
e di conseguenza:
P(S|B) = 0.6
P(S|C) = 0.4
 
Inoltre probabilita' di avere la malattia A, B, C
P(A) = 0.001
P(B) = 0.01
P(C) = 0.05
 
e tu cerchi
 
P(B|S) = P(S|B)P(B) / P(S)
 
per cui hai bisogno di:
 
P(S) = P(S|A)P(A) + P(S|B)P(B) + P(S|C)P(C)
 
ed effettivamente ti viene P(B|S) = 0.223
 
 
 
 
 
-- 
-riko
http://www.enrico-franchi.org/
 
http://rik0-techtemple.blogspot.com/
 

 Ci devo pensare un altro po' ;)
 
Allora, te lo dico io, dai.
 
L'errore nel tuo codice e' che estrai troppe volte. Devi estrarre una
volta per vedere *quale* malattia hai. La scelta la fai estraendo
uniforme e vedendo in che porzione di segmento cadi.
 
A questo punto ti segni cosa e' successo e puoi andare ad acchiappare il
giusto condizionamento per estrarre una seconda volta, che ti dice,
sapendo quale malattia hai se hai anche il sintomo.
 
Io il codice lo ho fatto in modo da avere un po' piu' di informazione.
In particolare illness_outcomes e' inutile (ma fa comodo se vuoi fare
del debug) e symptom_outcomes lo puoi sostituire con un valore per
symptom_outcomes[B] e uno per la somma delle volte che hai visto
manifestarsi il simbolo.
 
Il risultato, con 1000000 di test ha spesso errori nell'ordine di 10^-3,
che francamente e' un po' inaccettabile. Per un problema cosi' semplice,
si fa molto meglio usare la teoria. Comunque OP voleva vedere un
programma C che faccia sto calcolo e questo qua lo fa. 
 
 
#include <stdio.h>
#include <stdlib.h>
#include <time.h>
 
#define inrange(x, a, b) \
    (((x) >= (a)) && ((x) < (b)))
 
unsigned int trials = 1000000;
 
typedef enum {A=0, B=1, C=2, D=3} illness_t;
 
double illness_outcomes[] = {0.0, 0.0, 0.0, 0.0};
double symptom_outcomes[] = {0.0, 0.0, 0.0, 0.0};
 
double cond[] = {0.9, 0.6, 0.4, 0.0};
 
double uniform() {
    return ((double)rand()/(double)RAND_MAX);
}
 
double sum(double* values, size_t num) {
    double res = 0.0;
    for(; num; num--, values++) {
        res += *values;
    }
    return res;
}
 
int main() {
    double x;
    illness_t E;
 
    srand((unsigned)time(NULL));
 
    while(trials--) {
        x = uniform();
        if        (inrange(x, 0.0, 0.001)) {
            E = A;
        } else if (inrange(x, 0.001, 0.011)) {
            E = B;
        } else if (inrange(x, 0.011, 0.061)) {
            E = C;
        } else {
            E = D;
        }
 
        illness_outcomes[E] += 1;
        symptom_outcomes[E] += (uniform() < cond[E]);
    }
 
    printf("B: %lf\n",
            symptom_outcomes[B] /
            sum(symptom_outcomes,
                sizeof(symptom_outcomes)/sizeof(double)));


 non pensavo che avrei attirato tutti 'sti troll incompetenti!
 
Scusa, ma se scrivi mc a getto continuo, come mai ti sei trovato in
difficolta' su una cosa cosi' semplice? Non e' che per caso il problema
che ti interessa e' diverso da come lo abbiamo inteso tutti e che,
quindi, non e' cosi' banale?


 Mi sembra che simuli esattamente il problema, invece... :-(
 
Non lo fa. La tua ipotesi e' che hai una sola malattia oppure nessuna:
questo vuole dire che hai un'unica estrazione per capire quale malattia
hai (o nessuna). 


 
 
Oh, grande, grazie! ;)
 
Ciao!

 quindi, non e' cosi' banale?
 
In tutti gli altri casi non si trattava di usare un algoritmo con i suoi 
if e ragionamenti vari. Dovendo calcolare la distribuzione di una 
statistica per la quale non esiste una soluzione analitica (come quella 
stra-usata di Anderson-Darling, ad esempio) basta semplicemente 
applicare la formuletta ad una serie di numeri casuali per ottenere i 
vari quantili voluti. E questo � veramente banale; ovviamente bisogna 
scrivere bene tutto il programma che "gestisce" la simulazione, ma il 
calcolo della statistica in s� non si presta a fraintendimenti o 
ragionamenti sul flusso del programma (come invece accade per il 
problemino che ho postato).
 
Cristiano

 hai (o nessuna).
 
Ok, ho capito l'errore e ho visto anche il tuo codice.
 
Grazie
Cristiano
 

 Quindi sì, sulla fiducia bravi tutti a parte noi due: contento?
 
Da ciò che hai scritto tu e da ciò che ha scritto l'OP non si può 
avere nessuna fiducia sulle vostre capacità riguardo la statistica
e la probabilità.
 
E così pure sulle mie capacità.
 
È la realtà oggettiva, non c'è bisogno di offendersi.
 
 
 
 

 È la realtà oggettiva, non c'è bisogno di offendersi.
 
Non mi sono spiegato.
 
Figurati se mi sono offeso, che non capisco una cippa di matematica in
generale è risaputo (i.s.m. ne sa qualcosa delle mie domande sceme, non è
mica un segreto!), sulla statistica poi ho sempre avuto un rifiuto personale;
a chi me lo fa notare non posso che dirgli "eh, c'hai ragione! :)".
 
Quello che non.. comprendo, è il modo di fare, ma vabè, ognuno è fatto a
modo suo.
 
Ciao!

 che francamente e' un po' inaccettabile.
 
Be', ma la simulazione non è che si fa eseguendo una sola volta il 
codice e prendendo per buono il singolo risultato ottenuto, perché il 
risultato è un numero casuale con distribuzione da definire.
Il codice che hai postato viene eseguito molte volte, fino a quando un 
criterio predefinito non viene soddisfatto (ad esempio, la varianza dei 
singoli risultati deve essere inferiore ad un valore prestabilito).
 
 > Per un problema cosi' semplice, si fa molto meglio usare la teoria.
 
Non c'è dubbio, ma io ho detto fin dal primo post che a me interessava 
scrivere la simulazione per altri motivi (tra l'altro, il risultato 
esatto era già stato postato nel ng dal quale ho letto il problema).
 
Cristiano
 

 singoli risultati deve essere inferiore ad un valore prestabilito).
 
Per portare un esempio concreto, dopo qualche decina di secondi di 
simulazione con un misero dual-core E6400 (quindi la simulazione la 
faccio funzionare a 2 thread), ottengo:
P(B|S)= 0.223154 con un intervallo di confidenza al 99% pari a 1e-4. 
Sono convinto che il risultato sarebbe ampiamente sufficiente per la 
quasi totalità di applicazioni pratiche (ma anche senza "quasi").
 
Cristiano

P(S) = P(S|A)P(A) + P(S|B)P(B) + P(S|C)P(C)
 
Ma, Mb, Mc, O-(MaUMbUMc) è una partizione di O
dalla formula di Bayes:
 
P(S)=P(S|Ma)*P(Ma)+P(S|Mb)*P(Mb)+P(S|Mc)*P(Mc) 
+ P(S|O-(MaUMbUMc)) * P(O-(MaUMbUMc))=
=0.9 * 0.001 + 0.6 * 0.01 + 0.4*0.05 =
0.0009 + 0.006 + 0.02 =0,0269
 
P(Mb|S)=0.01*0.6/0,0269=0,223


On Tue, 16 Jul 2013 19:48:04 +0200, Cristiano  wrote:

mi sembra converge a 0.216 non a 0.223 ma forse dipende dal fatto
che bisognerebbe considerare almeno 3 "variabili random"
ovvero funzioni che fanno numeri casuali ognuna che parte da un seed 
diverso, quando se ne 
usa una sola x tutto l'esercizio
 

usa una sola x tutto l'esercizio
 
ci ho provato nn ho trovato riscontri... c'e' qualche cosa che nn
capisco, doveva risultare 0.223 o intorno a tale risultato 
 

uniforme e vedendo in che porzione di segmento cadi.
 
...

void  problema1(void)
{double       r;
 u32 nt,  cb, v;
 u32 a, b, c, pre, somma; // Malattie
 MLineare  a1, a2;
 
 nt=10000000; cb=0; somma=0;
 for(v= 0; v<nt; ++v) 
   {a=0; b=0; c=0;
    pre=0; // Sintomo non presente
 
    r=a1.drnd();
 
    if(r< 0.001)
       {a=1; if(a2.drnd()< 0.9) pre=1;}
    if(0.001<=r && r<0.011) 
       {b=1; if(a2.drnd()< 0.6) pre=1;}
    if(0.011<=r && r<0.061) 
       {c=1; if(a2.drnd()< 0.4) pre=1;}
 
    if(pre) 
      if(a+b+c==1) 
        {++somma; cb+=b;}
    }
 printf("%d  %g\n", cb, cb/ (double)somma);
}
 
void  problema2(void)
{double       r;
 u32 nt,  cb, v;
 u32 a, b, c, pre, somma; // Malattie
 MLineare  a1, a2;
 
 nt=100000000; cb=0; somma=0;
 for(v= 0; v<nt; ++v) 
   {a=0; b=0; c=0;
    pre=0; // Sintomo non presente
 
    r=a1.drnd();
 
    if(r< 0.001)
       {a=1; if(a2.drnd()< 0.9) pre=1;}
    if(0.1<=r && r<0.11) 
       {b=1; if(a2.drnd()< 0.6) pre=1;}
    if(0.2<=r && r<0.25) 
       {c=1; if(a2.drnd()< 0.4) pre=1;}
 
    if(pre) 
      if(a+b+c==1) 
        {++somma; cb+=b;}
    }
 printf("%d  %g\n", cb, cb/ (double)somma);
}
 
59874  0.222496
600599  0.223194
 
effettivamente...
 

         {c=1; if(a2.drnd()< 0.4) pre=1;}
 
In pratica, l'errore più evidente che ho fatto io è quello di aver usato 
un numero casuale per ogni malattia, invece di usare solo 1 numero 
cambiando i confronti negli if.
Inutile dire che la versione presentata da Enrico Franchi (con un solo 
"uniform" per le malattie) è decisamente più veloce della mia versione 
(che comunque non funzionava).
 
Comunque, nel tuo codice non capisco perché usi a1 e a2. Se la classe 
MLineare implementa un buon generatore, non ci sono problemi ad usare 
sempre a1 (come, del resto, abbiamo fatto finora).
 
Cristiano


si' si' ricordavo male... mi sembrava che potessero esserci problemi
con i generatori pseudo casuali...
d'altra parte se un generatore produce solo 0 o 1
che sia uscita la sequeza 0000000000000
non implica che il prossimo numero ad uscire abbia probabilita'
maggiore del 50% di essere ... giusto?
 

 maggiore del 50% di essere ... giusto?
 
uhm... per questo non c'è bisogno di essere un genio di statistica..
se vuoi sapere se un uscita sarà 0 o 1 la sequenza precedente non conta nulla.
se vuoi sapere qual'è la probalità che tu abbia una sequenza di N zeri dopo
N estrazioni è un altro conto.
 
Ciao!

 maggiore del 50% di essere ... giusto?
 
Nel caso di un buon generatore di numeri (pseudo-)casuali la probabilit� 
di generare 0 o 1 � sempre del 50%, a prescindere da ci� che � uscito prima.
 
Cristiano

Ciao!
 


ok
 

 numeri di fila uno <0.01 e uno <0.60 etc
 
Se è così, ti consiglio di usare un altro generatore.
 
Cristiano
 

 
 
perche non chiedi su un Ng di matematica?
 
Ciao