def boxForcing(bMin, bMax, radius, c,
angle): #confines the particles inside the sample
x = pl.uniform(bMin, bMax)
y = pl.uniform(bMin, bMax)
if x < (bMin + c * radius):
x = x + (radius) * (1 + c * pl.absolute(pl.sin(pl.radians(angle))))
if x > (bMax - c * radius):
x = bMin + c * radius
if x > (bMax - c * radius):
x = x - (radius) * (1 + c * pl.absolute(pl.sin(pl.radians(angle))))
if x < (bMin + c * radius):
x = bMax - c * radius
if y > (bMax - c * radius):
y = y - (radius) * (1 + c * pl.absolute(pl.cos(pl.radians(angle))))
if y < (bMin + c * radius):
y = bMax - c * radius
if y < (bMin + c * radius):
y = y + (radius) * (1 + c * pl.absolute(pl.cos(pl.radians(angle))))
if y > (bMax - c * radius):
y = bMin + c * radius
center = []
center.append([x, y])
return center
def kast_dart():
# kast en tilfeldig dart
# returnerer koordinatene til kastet
# x og y skal være mellom -1 og 1
x_koordinat = uniform(-1, 1)
y_koordinat = uniform(-1, 1)
return x_koordinat, y_koordinat
def montecarlo(qtd_aleatorios):
# carregando dados
dados = n.loadtxt('notas_filosofos.txt')
# notas de platão
minimo = 0.0
maximo = 10.0
# cuidado com std, para evitar picos
std = 0.4
notas_todas = []
qtd_medidas = 8 # 8 notas
qtd_agentes = 7 # 7 filósofos/compositores/...
for i in range(qtd_medidas):
# notas para cada coluna (por métrica)
notas = dados[:, i]
# 1. plotar a distribuição gaussiana com mu centrado em cada posição
int_x = p.arange(minimo, maximo, 0.1)
# não preciso mais disso... agora só basta interpolar...
#p.plot(int_x, [gauss(v, x, std) for v in int_x])
# 2. interpolar todas as curvas de distribuição, objetivando a curva toda
# somamos os vetores produzidos pela aplicação de guass em valores de int_x e depois dividimos por N=7
# por fim, temos um vetor da média, e então interpolamos linearmente usando interp1d
# essa é a função interpolada para todas as 8 medidas
f = interp1d(
int_x,
reduce(lambda a, b: a + b, [
n.array([gauss(v, each, std) for v in int_x]) for each in notas
]) / qtd_agentes)
#p.plot(int_x, [f(v) for v in int_x], 'bx')
# 3. essa curva define a distribuição que usaremos como p(x) em monte carlo
novos = []
for i in range(1000):
# 1. sorteia um valor uniforme entre min e max
v = p.uniform(minimo + 1, maximo - 1)
# 2. calcula p(v)
fv = f(v)
# 3. sorteia um valor uniforme entre 0 e 1
a = p.uniform()
# 4. se a < v => guarda v na lista
if a < fv:
novos.append(v)
notas_todas.append(novos)
#p.hist(dados[0], normed=1)
aleatorios_todos = []
for i in range(qtd_aleatorios):
aleatorios_todos.append(
[r.choice(notas_todas[i]) for i in range(qtd_medidas)])
p.hist([r.choice(notas_todas[i]) for i in range(qtd_medidas)],
normed=1)
return aleatorios_todos
def init():
global u, v, nextu, nextv
u = pylab.zeros([n, n])
v = pylab.zeros([n, n])
for x in range(n):
for y in range(n):
u[x, y] = 1. + pylab.uniform(-0.03, 0.03)
v[x, y] = 1. + pylab.uniform(-0.03, 0.03)
nextu = pylab.zeros([n, n])
nextv = pylab.zeros([n, n])
def lists(tau): global x, xarray varray = [] xtarray = [] i = 0 while(i < len(xarray)-1): v = [xarray[i]+pylab.uniform(-0.03, 0.03)] varray.append(v) xtarray.append(xarray[i+1]+pylab.uniform(-0.05, 0.05)) i += tau return varray, xtarray
def montecarlo(qtd_aleatorios):
# carregando dados
dados = n.loadtxt('notas_filosofos.txt')
# notas de platão
minimo = 0.0
maximo = 10.0
# cuidado com std, para evitar picos
std = 0.4
notas_todas = []
qtd_medidas = 8 # 8 notas
qtd_agentes = 7 # 7 filósofos/compositores/...
for i in range(qtd_medidas):
# notas para cada coluna (por métrica)
notas = dados[:,i]
# 1. plotar a distribuição gaussiana com mu centrado em cada posição
int_x = p.arange(minimo, maximo, 0.1)
# não preciso mais disso... agora só basta interpolar...
#p.plot(int_x, [gauss(v, x, std) for v in int_x])
# 2. interpolar todas as curvas de distribuição, objetivando a curva toda
# somamos os vetores produzidos pela aplicação de guass em valores de int_x e depois dividimos por N=7
# por fim, temos um vetor da média, e então interpolamos linearmente usando interp1d
# essa é a função interpolada para todas as 8 medidas
f = interp1d(int_x, reduce(lambda a,b: a + b, [n.array([gauss(v, each, std) for v in int_x]) for each in notas])/qtd_agentes)
#p.plot(int_x, [f(v) for v in int_x], 'bx')
# 3. essa curva define a distribuição que usaremos como p(x) em monte carlo
novos = []
for i in range(1000):
# 1. sorteia um valor uniforme entre min e max
v = p.uniform(minimo+1, maximo-1)
# 2. calcula p(v)
fv = f(v)
# 3. sorteia um valor uniforme entre 0 e 1
a = p.uniform()
# 4. se a < v => guarda v na lista
if a < fv:
novos.append(v)
notas_todas.append(novos)
#p.hist(dados[0], normed=1)
aleatorios_todos = []
for i in range(qtd_aleatorios):
aleatorios_todos.append([r.choice(notas_todas[i]) for i in range(qtd_medidas)])
p.hist([r.choice(notas_todas[i]) for i in range(qtd_medidas)], normed=1)
return aleatorios_todos
def montecarlo2(qtd_aleatorios):
# carregando dados
dados = n.loadtxt('notas_filosofos.txt')
minimo = 1.0
maximo = 9.0
samples_todos = []
j = 0
# repetimos até termos a quantidade que queremos de aleatorios
while (len(samples_todos) < qtd_aleatorios / 7):
d_todas = []
xs_todas = []
for i in range(len(dados)):
# 1. notas para cada linha (cada filósofo), notas = {x1, x2, ..., x8}
notas = dados[i]
# 2. calculamos 8 pontos aleatórios xsN e a distância dK para cada filósofo
xs = []
for i in range(len(notas)):
xs.append(p.uniform(minimo, maximo))
#print 'xs', xs
xs_todas.append(xs)
# 3. calculamos dK
dk = n.sqrt(
n.sum([(xs[i] - notas[i])**2 for i in range(len(notas))]))
# 4. guardamos dk em d_todas
d_todas.append(dk)
desv = 0.4
po = n.sum([n.exp(-0.5 * ((d_todas[i]**2) / desv)) for i in range(7)])
#po = n.sum([n.exp(-0.5*((d_todas[i]**2)/n.mean(n.std(dados, 0)))) for i in range(7)])
#_std = 4
#_mu = 0
#po = n.sum([n.exp(-((d_todas[i]-_mu)**2) / (2*_std)) / n.sqrt(2*n.pi*_std) for i in range(7)])
#print 'sigma', n.mean(n.std(dados, 0))
#print '\nsimulação: ', j+1, '\n\nxs:\n', xs_todas, '\n\np: ', po
# agora o fv é nosso po
a = p.uniform()
print a, po
if a < po:
samples_todos.append(xs_todas)
j += 1
print len(samples_todos)
# concatena sublistas [[a], [b,c]] => [a, b, c]
return sum(samples_todos, [])
def montecarlo2(qtd_aleatorios):
# carregando dados
dados = n.loadtxt('notas_filosofos.txt')
minimo = 1.0
maximo = 9.0
samples_todos = []
j = 0
# repetimos até termos a quantidade que queremos de aleatorios
while (len(samples_todos) < qtd_aleatorios/7):
d_todas = []
xs_todas = []
for i in range(len(dados)):
# 1. notas para cada linha (cada filósofo), notas = {x1, x2, ..., x8}
notas = dados[i]
# 2. calculamos 8 pontos aleatórios xsN e a distância dK para cada filósofo
xs = []
for i in range(len(notas)):
xs.append(p.uniform(minimo, maximo))
#print 'xs', xs
xs_todas.append(xs)
# 3. calculamos dK
dk = n.sqrt(n.sum([(xs[i] - notas[i])**2 for i in range(len(notas))]))
# 4. guardamos dk em d_todas
d_todas.append(dk)
desv = 0.4
po = n.sum([n.exp(-0.5*((d_todas[i]**2)/desv)) for i in range(7)])
#po = n.sum([n.exp(-0.5*((d_todas[i]**2)/n.mean(n.std(dados, 0)))) for i in range(7)])
#_std = 4
#_mu = 0
#po = n.sum([n.exp(-((d_todas[i]-_mu)**2) / (2*_std)) / n.sqrt(2*n.pi*_std) for i in range(7)])
#print 'sigma', n.mean(n.std(dados, 0))
#print '\nsimulação: ', j+1, '\n\nxs:\n', xs_todas, '\n\np: ', po
# agora o fv é nosso po
a = p.uniform()
print a, po
if a < po:
samples_todos.append(xs_todas)
j+=1
print len(samples_todos)
# concatena sublistas [[a], [b,c]] => [a, b, c]
return sum(samples_todos, [])
def comp_osc_ind3(self,pop_id = 'all',nr_peaks=5,trange=5,frange_max=1000,kernel_w=2,resolution=1e-2, time_range=[], bin_w = 200.): '''trange (Hz): remove points +/- trange around each peak''' '''Identify the rate and number of spikes in each window and make a corresponding poisson process''' #Make the time bins if time_range == []: time1 = 0. time2 = self.pars['T_wup']+self.pars['T_sim'] else: time1 = time_range[0] time2 = time_range[1] bins = np.arange(time1,time2+(bin_w)/2,bin_w) osc_ind_lis = [] pos_lis = [] ff_pos1_lis = [] ff_pos2_lis = [] psd_lis = [] ff_lis = [] ff2_lis = [] #Enter the bins one by one for ii in (range(len(bins)-1)): fir_rate = self.comp_mean_rate(pop_id = pop_id, time_range = [bins[ii],bins[ii+1]], nmax = 1000) # Generate a poisson process of the same rate multiple times and make an average if fir_rate > 5: Mu = fir_rate * ((bins[ii+1]-bins[ii])/1000.) poiss_spikes = pl.uniform(bins[ii],bins[ii+1], int(round(Mu))) poiss_spikes = poiss_spikes[poiss_spikes < bins[ii+1]] poiss_spikes.sort() poiss_psth,p_kernel,xx = misc2.kde(poiss_spikes,kernel_w,resolution,1,1,'normal',bin_w) p_psd,p_ff,p_vmax,p_fmax = misc2.psd(poiss_psth, resolution) p_ff_step = np.diff(p_ff)[0] p_psd = p_psd[p_ff <= frange_max] p_ff2 = p_ff[p_ff <= frange_max] return p_psd, p_ff2
def lists(tau):
global x, xarray
varray = []
xtarray = []
i = 2 * tau
while (i < len(xarray) - 1):
v = [xarray[i], xarray[i - tau], xarray[i - 2 * tau]]
varray.append(v)
xtarray.append(xarray[i + 1] + pylab.uniform(-0.05, 0.05))
i += 1
return varray, xtarray
def histogram_2():
plb.figure(2)
gaus_dist = plb.normal(-2, 2, size=512)
unif_dist = plb.uniform(-5, 5, size=512)
plb.hist(unif_dist, bins=24, histtype='stepfilled', normed=True, color='cyan', label='Uniform')
plb.hist(gaus_dist, bins=24, histtype='stepfilled', normed=True, color='orange', label='Gaussian', alpha=0.65)
plb.legend(loc='upper right')
plb.title('Gaussian vs Uniform distribution / Histrogram')
plb.xlabel('Value')
plb.ylabel('Frequency')
plb.grid(True)
plb.pause(5)
def montecarlo(f, a, b, eps=1e-3, nmin=100, nmax=1000000):
""" Monte Carlo integration.
Here, f is the integrand, a and b are arrays giving the limits
of the integral, and eps is the desired accuracy.
The parameters nmin and nmax specify the minimum and
maximum number of random points to use. """
a = pylab.asarray(a)
b = pylab.asarray(b)
vol = pylab.prod(b - a)
s = 0.0 # running average of f(x)
ssq = 0.0 # running sum of (f(x)-s)**2
n = 0
while n < nmax:
n += 1
x = pylab.uniform(a, b)
fx = f(x)
d = fx - s
s += d / n
ssq += d * (fx - s)
err = ssq**0.5 / n # assume n-1 ~= n
if n > nmin and err < eps * abs(s):
break
return vol * s
# por fim, temos um vetor da média, e então interpolamos linearmente usando interp1d
# essa é a função interpolada para todas as 8 medidas
f = interp1d(
int_x,
reduce(
lambda a, b: a + b,
[n.array([gauss(v, each, std) for v in int_x])
for each in notas]) / qtd_agentes)
#p.plot(int_x, [f(v) for v in int_x], 'bx')
# 3. essa curva define a distribuição que usaremos como p(x) em monte carlo
novos = []
for i in range(1000):
# 1. sorteia um valor uniforme entre min e max
v = p.uniform(minimo + 1, maximo - 1)
# 2. calcula p(v)
fv = f(v)
# 3. sorteia um valor uniforme entre 0 e 1
a = p.uniform()
# 4. se a < v => guarda v na lista
if a < fv:
novos.append(v)
notas_todas.append(novos)
#p.hist(dados[0], normed=1)
qtd_aleatorios = 10
aleatorios_todos = []
minimo = 1.0
maximo = 9.0
# cuidado com std, para evitar picos
std = 0.4
samples_todos = []
for j in range(100):
d_todas = []
xs_todas = []
for i in range(len(dados)):
# 1. notas para cada linha (cada filósofo), notas = {x1, x2, ..., x8}
notas = dados[i]
# 2. calculamos 8 pontos aleatórios xsN e a distância dK para cada filósofo
xs = []
for i in range(len(notas)):
xs.append(p.uniform(minimo, maximo))
xs_todas.append(xs)
# 3. calculamos dK
dk = n.sqrt(n.sum([(xs[i] - notas[i])**2 for i in range(len(notas))]))
# 4. guardamos dk em d_todas
d_todas.append(dk)
po = n.sum([n.exp(-0.5*((d_todas[i]**2)/n.std(dados, 0))) for i in range(7)])
print '\nsimulação: ', j+1, '\n\nxs:\n', xs_todas, '\n\np: ', po
# agora o fv é nosso po
a = p.uniform()
# -*- coding: utf-8 -*-
import pylab as p
# distribuição normal
def f(x):
mu = 0
std = 1
return p.exp(-((x - mu)**2)/(2*std)) / p.sqrt(2*p.pi*std)
novos = []
minimo = -10.0
maximo = 10.0
for i in range(1000):
# 1. sorteia um valor uniforme entre min e max
v = p.uniform(minimo, maximo)
# 2. calcula p(v)
fv = f(v)
# 3. sorteia um valor uniforme entre 0 e 1
a = p.uniform()
# 4. se a < v => guarda v na lista
if a < fv:
novos.append(v)
#p.hist(novos, normed=1, alpha=0.75)
int_x = p.arange(minimo, maximo,0.1)
p.plot(int_x, [f(x) for x in int_x])
p.axis([minimo, maximo, 0, 0.6])
def epsilon_greedy_action(self, state):
p = uniform()
if p < self.epsilon:
return randint(0, self.env.get_num_actions())
else:
return argmax(self.get_q(state))
def observe():
global x, xarray
xarray.append(x + pylab.uniform(-0.05, 0.05))
dados_boot = []
def gauss(x, mu=0, std=1):
return p.exp(-((x - mu)**2)/(2*std)) / p.sqrt(2*p.pi*std)
# repetimos até termos a quantidade que queremos de aleatorios
while (len(dados_boot) < qtd_aleatorios/7):
d_todas = []
xs_todas = []
for i in xrange(len(dados_orig)):
# 1. notas para cada linha (cada filósofo), notas = {x1, x2, ..., x8}
notas = dados_orig[i]
# 2. calculamos 8 pontos aleatórios xsN e a distância dK para cada filósofo
xs = [p.uniform(minimo, maximo) for i in range(len(notas))]
xs_todas.append(xs)
# 3. calculamos dK
dk = n.sqrt(n.sum([(xs[i] - notas[i])**2 for i in range(len(notas))]))
# 4. guardamos dk em d_todas
d_todas.append(dk)
po = n.sum([gauss(k, 0, std) for k in d_todas])
qo = 7 / po
#print 'po', po, 'qo', qo
#print 'd_todas', d_todas
# se a < p(x) então ficamos com o valor
a = p.uniform()
def gauss(x, mu=0, std=1):
return p.exp(-((x - mu)**2) / (2 * std)) / p.sqrt(2 * p.pi * std)
# repetimos até termos a quantidade que queremos de aleatorios
while (len(dados_boot) < qtd_aleatorios / 7):
d_todas = []
xs_todas = []
for i in xrange(len(dados_orig)):
# 1. notas para cada linha (cada filósofo), notas = {x1, x2, ..., x8}
notas = dados_orig[i]
# 2. calculamos 8 pontos aleatórios xsN e a distância dK para cada filósofo
xs = [p.uniform(minimo, maximo) for i in range(len(notas))]
xs_todas.append(xs)
# 3. calculamos dK
dk = n.sqrt(n.sum([(xs[i] - notas[i])**2 for i in range(len(notas))]))
# 4. guardamos dk em d_todas
d_todas.append(dk)
po = n.sum([gauss(k, 0, std) for k in d_todas])
qo = 7 / po
#print 'po', po, 'qo', qo
#print 'd_todas', d_todas
# se a < p(x) então ficamos com o valor
a = p.uniform()
# Histogram 2/2:
import pylab as plb
plb.figure(2)
gaus_dist = plb.normal(size=512) # create a random floating point vector
unif_dist = plb.uniform(-5, 5,
size=512) # Create a uniform distribution vector
#plot the histogrm with specific bin number, color, transparency, label
plb.hist(unif_dist,
bins=24,
histtype='stepfilled',
density=True,
color='cyan',
label='Uniform')
plb.hist(gaus_dist,
bins=24,
histtype='stepfilled',
density=True,
color='orange',
label='Gaussian',
alpha=0.65)
plb.legend(loc='upper left')
plb.title("Gaussian vs Uniform distribution / Histogram")
plb.xlabel("value")
plb.ylabel("Frequency")
plb.grid(True)
plb.pause(5)
gaus_dist = plb.normal(-2, 2, size=512) #random vector
plb.hist(gaus_dist, normed=True, bins=24)
plb.title("Gaussian Distribution / Histogram")
plb.xlabel("Value")
plb.ylabel("Frequency")
plb.grid(True)
plb.show()
# In[24]:
#Histogram 2
plb.figure(2)
gaus_dist = plb.normal(size=512)
unif_dist = plb.uniform(-5, 5, size=512) # uniform distibution vector
plb.hist(unif_dist,
bins=24,
histtype='stepfilled',
normed=True,
color='cyan',
label='uniform')
plb.hist(gaus_dist,
bins=24,
histtype='stepfilled',
normed=True,
color='orange',
label='Gaussian',
alpha=0.65)
# distribuição normal
def f(x):
mu = 0
std = 1
return p.exp(-((x - mu)**2) / (2 * std)) / p.sqrt(2 * p.pi * std)
novos = []
minimo = -10.0
maximo = 10.0
for i in range(1000):
# 1. sorteia um valor uniforme entre min e max
v = p.uniform(minimo, maximo)
# 2. calcula p(v)
fv = f(v)
# 3. sorteia um valor uniforme entre 0 e 1
a = p.uniform()
# 4. se a < v => guarda v na lista
if a < fv:
novos.append(v)
#p.hist(novos, normed=1, alpha=0.75)
int_x = p.arange(minimo, maximo, 0.1)
p.plot(int_x, [f(x) for x in int_x])
p.axis([minimo, maximo, 0, 0.6])
def kast_dart():
# kast en tilfeldig dart
x_koordinat = uniform(-1, 1)
y_koordinat = uniform(-1, 1)
return x_koordinat, y_koordinat
minimo = 1.0
maximo = 9.0
# cuidado com std, para evitar picos
std = 0.4
samples_todos = []
for j in range(100):
d_todas = []
xs_todas = []
for i in range(len(dados)):
# 1. notas para cada linha (cada filósofo), notas = {x1, x2, ..., x8}
notas = dados[i]
# 2. calculamos 8 pontos aleatórios xsN e a distância dK para cada filósofo
xs = []
for i in range(len(notas)):
xs.append(p.uniform(minimo, maximo))
xs_todas.append(xs)
# 3. calculamos dK
dk = n.sqrt(n.sum([(xs[i] - notas[i])**2 for i in range(len(notas))]))
# 4. guardamos dk em d_todas
d_todas.append(dk)
po = n.sum(
[n.exp(-0.5 * ((d_todas[i]**2) / n.std(dados, 0))) for i in range(7)])
print '\nsimulação: ', j + 1, '\n\nxs:\n', xs_todas, '\n\np: ', po
# agora o fv é nosso po
a = p.uniform()
# 2. interpolar todas as curvas de distribuição, objetivando a curva toda
# somamos os vetores produzidos pela aplicação de guass em valores de int_x e depois dividimos por N=7
# por fim, temos um vetor da média, e então interpolamos linearmente usando interp1d
# essa é a função interpolada para todas as 8 medidas
f = interp1d(
int_x,
reduce(lambda a, b: a + b, [n.array([gauss(v, each, std) for v in int_x]) for each in notas]) / qtd_agentes,
)
# p.plot(int_x, [f(v) for v in int_x], 'bx')
# 3. essa curva define a distribuição que usaremos como p(x) em monte carlo
novos = []
for i in range(1000):
# 1. sorteia um valor uniforme entre min e max
v = p.uniform(minimo + 1, maximo - 1)
# 2. calcula p(v)
fv = f(v)
# 3. sorteia um valor uniforme entre 0 e 1
a = p.uniform()
# 4. se a < v => guarda v na lista
if a < fv:
novos.append(v)
notas_todas.append(novos)
# p.hist(dados[0], normed=1)
qtd_aleatorios = 10
aleatorios_todos = []
