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 = []