"""Simulazione dello strumento di Galton nelle tre dimensioni ideato dal prof. S. Grillo le funzioni principali sono due simulazione(lato, passo, liv,n=1000) e simulazione_pallina(lato, passo, liv,gr,n=4) lato e' il lato del quadrato passo e' la distanza fra i piani di quadrati liv e' il num. di livelli (compreso il quadrato iniziale) n e' il numero di palline da lanciare con valore predefinito simulazione_pallina visualizza la pallina che "rotola" dopo il clic del mouse ed e' lenta; stampa gli indici della casella di arrivo simulazione e' molto piu' veloce ma non visualizza la pallina stampa invece i risultati sperimentali e teorici nella finestra di shell """ from graftarta2 import Graf import math, random, fatt from graphics import * gr=Graf("Strumento di S. Grillo",500,450) gr.coordinate(-500,-450,500,450) gr.nascondi_tarta() gr.mostra_palla(10) gr.imbardaR(math.pi/6) gr.rollaR(math.pi/8) # piccolo vocabolario per semplificare la scrittura im=gr.imbarda be=gr.beccheggia pm=math.pi/2 av=gr.avanti3d psu=gr.pennasu pgiu=gr.pennagiu ap=gr.aspos3d cp=gr.colorePenna ap2d=gr.asPos p2dx=gr.P2d.x p2dy=gr.P2d.y def assi3d(t): t.colorePenna("red") t.avanti3d(500) t.avanti3d(-1000) t.avanti3d(500) t.beccheggia(math.pi/2) t.colorePenna("green") t.avanti3d(500) t.avanti3d(-1000) t.avanti3d(500) t.beccheggia(-math.pi/2) t.imbarda(math.pi/2) t.colorePenna("yellow") t.avanti3d(500) t.avanti3d(-1000) t.avanti3d(500) t.imbarda(-math.pi/2) def qua(lato): for j in range(4): av(lato) im(pm) def centro_sotto(lato, passo): psu() av(lato/2) im(pm) av(lato/2) im(-pm) be(-pm) av(passo) be(pm) pgiu() def torna_sopra(lato,passo): psu() be(pm) av(passo) be(-pm) im(-pm) av(lato/2) im(pm) av(-lato/2) pgiu() def quad_4quad(lato,passo,liv): if liv>0: #cp("red") qua(lato) centro_sotto(lato, passo) for k in range(4): quad_4quad(lato,passo,liv-1) im(pm) torna_sopra(lato,passo) def posiz_inizio(): psu() ap(0,360,0) pgiu() def scendi(passo): be(-pm) av(passo) be(pm) def scegli_vai_al_centro(lato,passo): q=random.randint(0,3) if q == 0: av(lato/2) im(pm) av(lato/2) im(-pm) if q == 1: av(-lato/2) im(pm) av(lato/2) im(-pm) if q == 2: av(-lato/2) im(-pm) av(lato/2) im(pm) if q == 3: av(lato/2) im(-pm) av(lato/2) im(pm) scendi(passo) def caduta(lato, passo, liv): for k in range(liv-1): scegli_vai_al_centro(lato,passo) def prepara(lato, passo, liv): psu() be(pm) av(360) be(-pm) av(-lato/2) im(-pm) av(lato/2) im(pm) pgiu() cp("red") quad_4quad(lato, passo, liv) cp("black") #raw_input() def avpallina(dist,gr): ritarda(80000) av(dist) #print p2dx, p2dy ap2d(gr.P2d.x,gr.P2d.y) def scendi_pallina(passo,gr): be(-pm) avpallina(passo,gr) be(pm) def scegli_vai_al_centro_pallina(lato,passo,gr): q=random.randint(0,3) if q == 0: avpallina(lato/2,gr) im(pm) avpallina(lato/2,gr) im(-pm) if q == 1: avpallina(-lato/2,gr) im(pm) avpallina(lato/2,gr) im(-pm) if q == 2: avpallina(-lato/2,gr) im(-pm) avpallina(lato/2,gr) im(pm) if q == 3: avpallina(lato/2,gr) im(-pm) avpallina(lato/2,gr) im(pm) scendi_pallina(passo,gr) def caduta_pallina(lato, passo, liv,gr): for k in range(liv-1): scegli_vai_al_centro_pallina(lato,passo,gr) def ritarda(a): for j in range(a): d=random.random() def simulazione_pallina(lato, passo, liv,gr,n=4): """caduta di una singola pallina dopo il clic col mouse""" print 'cliccare nel grafico' prepara(lato, passo, liv) for d in range(n): gr.getMouse() posiz_inizio() scendi_pallina(passo,gr) caduta_pallina(lato, passo, liv,gr) cx, cz = int(round(gr.P.x))/lato+liv/2, int(round(gr.P.z))/lato+liv/2 print cx, cz gr.getMouse() gr.close() def stampa_matr(L,liv): for j in range(liv): print for k in range(liv): print str(round(L[j][k],3))+' ('+str(round(prob_casella(j,k,liv),3))+')','\t', print def prob_casella(j,k,liv): return fatt.binomiale(liv-1,j)*fatt.binomiale(liv-1,k)*(0.25)**(liv-1) def simulazione(lato, passo, liv,n=1000): matr=[] for j in range(liv): matr.append([]) for j in range(liv): for k in range(liv): matr[j].append(0) prepara(lato, passo, liv) for d in range(n): posiz_inizio() scendi(passo) caduta(lato, passo, liv) cx, cz = int(round(gr.P.x))/lato+liv/2, int(round(gr.P.z))/lato+liv/2 matr[cx][cz]=matr[cx][cz]+1 print 'Strumento di Galton in 3 dimensioni' print 'ideato da S. Grillo' print 'simulazione lancio ', n,' palline con ',liv-1,' livelli di scelta casuale' print print 'Numero di palline in ciascun contenitore, palline attese fra parentesi' for j in range(liv): print for k in range(liv): print str(matr[j][k])+' ('+str(round(prob_casella(j,k,liv)*n))+')','\t', print n=float(n) freq=[] for j in range(liv): freq.append([]) for j in range(liv): for k in range(liv): freq[j].append(matr[j][k]/n) print print 'Frequenze sperimentali e probab. teorica fra parentesi' stampa_matr(freq,liv) return matr def principale(): """diventa lenta la simulazione""" print 'Strumento di Galton in 3 dimensioni' print 'ideato da S. Grillo' print liv=input('quanti livelli (3,4,5)? ') print n=input('quante palline ? ') simulazione(80,120,liv,n) #principale() #assi3d(gr) #sg=simulazione(80,120,5,1000) simulazione_pallina(80,120,5,gr,6)