In recent weeks, with the help of the community, I have developed this program that simulates a signal game during two rounds with four participants. The game that simulates is that in each round each participant shows a signal and observes another signal. The signals shown and observed are stored in some memory dictionaries. In the first round the signals (letters) are assigned randomly, and in the second round the signals are assigned depending on a probability equation that takes into account the memory history stored in the dictionaries. The output shows (in order of participants: participant 1, participant 2, participant 3, participant 4):
Signals shown by participants
Signals observed by participants
Accumulated memory of displayed signs
Accumulated memory of observed signals
I would like to ask the community for help:
Simplify this code to do the same.
Allow to change the initial pairings and that the memory dictionaries keep the signals properly.
import random
emparejamientos= ([[1,2],[3,4], #ronda 1 (participante 1 juega con 2 y 3 con 4)
[1,3],[2,4]]) #ronda 2 (1 con 3 y 2 con 4)
s1=1
s2=0
s3=0
s4=0
b=0.5
x=0.5
m=0.02
Muestra_part1 = {"A":0,"B":0,"C":0,"D":0,"E":0,"F":0,"G":0,"H":0}
Observa_part1 = {"A":0,"B":0,"C":0,"D":0,"E":0,"F":0,"G":0,"H":0}
Muestra_part2 = {"A":0,"B":0,"C":0,"D":0,"E":0,"F":0,"G":0,"H":0}
Observa_part2 = {"A":0,"B":0,"C":0,"D":0,"E":0,"F":0,"G":0,"H":0}
Muestra_part3 = {"A":0,"B":0,"C":0,"D":0,"E":0,"F":0,"G":0,"H":0}
Observa_part3 = {"A":0,"B":0,"C":0,"D":0,"E":0,"F":0,"G":0,"H":0}
Muestra_part4 = {"A":0,"B":0,"C":0,"D":0,"E":0,"F":0,"G":0,"H":0}
Observa_part4 = {"A":0,"B":0,"C":0,"D":0,"E":0,"F":0,"G":0,"H":0}
#RONDA 1
#Senales mostradas por cada participante en ronda 1
S1, S2, S3, S4 = random.sample("ABCDEFGH", 4) #asignacion de senales random sin repeticion
print "Senales mostradas en la generacion 1 \n {0}".format((S1, S2, S3, S4))
#Almacen de senales mostradas en el diccionario (memoria de senales mostradas)
for n in range(1):
Muestra_part1[S1] += 1
for n in range(1):
Muestra_part2[S2] += 1
for n in range(1):
Muestra_part3[S3] += 1
for n in range(1):
Muestra_part4[S4] += 1
#Almacen de senales observadas en el diccionario (memoria de senales observadas)
if emparejamientos[0]==[1,2]:
Observa_part1[S2] +=1
Observa_part2[S1] +=1
if emparejamientos[1]==[3,4]:
Observa_part3[S4] += 1
Observa_part4[S3] += 1
#RONDA 2
#Probabilidad para cada participante de mostrar una senal determinada en 2a ronda
def with_b(muestra, observa, s):
result = ((0.98) * (1.0 - 0) * (1.0 - x) * muestra) + ((0.98) * (1.0 - 0) * (x) * observa) + ((0.98) * 0 * s) + ((m / 8))
if not (muestra == observa == 0):
result = ((0.98) * (1.0 - b) * (1.0 - x) * muestra) + ((0.98) * (1.0 - b) * (x) * observa) + ((0.98) * b * s) + ((m / 8))
return result
Prob_S1_part1 = with_b(Muestra_part1[S1], Observa_part1[S1], s1)
Prob_S2_part1 = with_b(Muestra_part1[S2], Observa_part1[S2], s2)
Prob_S3_part1 = with_b(Muestra_part1[S3], Observa_part1[S3], s3)
Prob_S4_part1 = with_b(Muestra_part1[S4], Observa_part1[S4], s4)
Prob_S1_part2 = with_b(Muestra_part2[S1], Observa_part2[S1], s1)
Prob_S2_part2 = with_b(Muestra_part2[S2], Observa_part2[S2], s2)
Prob_S3_part2 = with_b(Muestra_part2[S3], Observa_part2[S3], s3)
Prob_S4_part2 = with_b(Muestra_part2[S4], Observa_part2[S4], s4)
Prob_S1_part3 = with_b(Muestra_part3[S1], Observa_part3[S1], s1)
Prob_S2_part3 = with_b(Muestra_part3[S2], Observa_part3[S2], s2)
Prob_S3_part3 = with_b(Muestra_part3[S3], Observa_part3[S3], s3)
Prob_S4_part3 = with_b(Muestra_part3[S4], Observa_part3[S4], s4)
Prob_S1_part4 = with_b(Muestra_part4[S1], Observa_part4[S1], s1)
Prob_S2_part4 = with_b(Muestra_part4[S2], Observa_part4[S2], s2)
Prob_S3_part4 = with_b(Muestra_part4[S3], Observa_part4[S3], s3)
Prob_S4_part4 = with_b(Muestra_part4[S4], Observa_part4[S4], s4)
#Senales que muestran los participantes en la RONDA 2. Asignadas segun las probabilidades dadas por la ecuacion de memorias
opciones = [S1, S2, S3, S4]
probabilidades1 = [Prob_S1_part1, Prob_S2_part1, Prob_S3_part1, Prob_S4_part1]
probabilidades2 = [Prob_S1_part2, Prob_S2_part2, Prob_S3_part2, Prob_S4_part2]
probabilidades3 = [Prob_S1_part3, Prob_S2_part3, Prob_S3_part3, Prob_S4_part3]
probabilidades4 = [Prob_S1_part4, Prob_S2_part4, Prob_S3_part4, Prob_S4_part4]
from random import random
from bisect import bisect
def choice(opciones, probs):
probAcumuladas=[]
aux = 0
for p in probs:
aux += p
probAcumuladas.append(aux)
r = random() * probAcumuladas[-1]
op = bisect(probAcumuladas, r)
return opciones[op]
eleccion1 = choice(opciones, probabilidades1) #senal mostrada por participante 1 en ronda 2
eleccion2 = choice(opciones, probabilidades2) #senal mostrada por participante 2 en ronda 2
eleccion3 = choice(opciones, probabilidades3) #senal mostrada por participante 3 en ronda 2
eleccion4 = choice(opciones, probabilidades4) #senal mostrada por participante 4 en ronda 2
print "Senales mostradas en la generacion 2 \n {0}".format((eleccion1, eleccion2, eleccion3, eleccion4))
#Almacen de senales mostradas en el diccionario (memoria de senales mostradas)
if eleccion1 == S1:
Muestra_part1[S1] +=1
if eleccion1 == S2:
Muestra_part1[S2] +=1
if eleccion1 == S3:
Muestra_part1[S3] +=1
if eleccion1 == S4:
Muestra_part1[S4] +=1
if eleccion2 == S1:
Muestra_part2[S1] +=1
if eleccion2 == S2:
Muestra_part2[S2] +=1
if eleccion2 == S3:
Muestra_part2[S3] +=1
if eleccion2 == S4:
Muestra_part2[S4] +=1
if eleccion3 == S1:
Muestra_part3[S1] +=1
if eleccion3 == S2:
Muestra_part3[S2] +=1
if eleccion3 == S3:
Muestra_part3[S3] +=1
if eleccion3 == S4:
Muestra_part3[S4] +=1
if eleccion4 == S1:
Muestra_part4[S1] +=1
if eleccion4 == S2:
Muestra_part4[S2] +=1
if eleccion4 == S3:
Muestra_part4[S3] +=1
if eleccion4 == S4:
Muestra_part4[S4] +=1
print "Memoria acumulada de senales mostradas \n {0}".format ((Muestra_part1, Muestra_part2, Muestra_part3, Muestra_part4))
#Almacen de senales observadas en el diccionario (memoria de senales observadas)
if emparejamientos[2]==[1,3]:
Observa_part1[eleccion3] +=1
Observa_part3[eleccion1] +=1
if emparejamientos[3]==[2,4]:
Observa_part2[eleccion4] += 1
Observa_part4[eleccion2] += 1
print "Memorias acumulada de senales observadas \n {0}".format ((Observa_part1, Observa_part2, Observa_part3, Observa_part4))