#Preâmbulo (carregando pacotes)
import scipy.special as sps
import numpy as np
import matplotlib.pyplot as plt
import random
from random import shuffle
import scipy as sp
from scipy import misc
from IPython.display import Latex
import math 
from math import log
% matplotlib inline

"""
Explanation: <font size="6px" font color="blue" face="Times New Roman"><b>Estudo de Modelos de Distribuição Estatística</b></font>
<font size="3px" font color="black" face="Times New Roman"><b>Objetivo:</b></font> Estudar e descobrir qual é a melhor forma de se utilizar números aleatórios ao longo de uma distribuição estatística para a gerar de ruído.
End of explanation
"""


#tentando outras distribuições de ruído aleatório
shape, scale = 2., 1. # mean and width
s = np.random.standard_gamma(shape, 1000000)



count, bins, ignored = plt.hist(s, 50, normed=True)
y = bins**(shape-1) * ((np.exp(-bins/scale))/ 
(sps.gamma(shape) * scale**shape))
plt.plot(bins, y, linewidth=2, color='r')
plt.show()

"""
Explanation: <font size="4px" font color="black" face="Times New Roman"><b>I- A Distribuição Gama</b></font>
A função gama pode ser descrita como:
$$
\Gamma(\alpha)=\int_{0}^{\infty} x^{\alpha -1} e^{-x}\, dx ,
$$
Que por derivação implícita pode ser reescrita da forma:
$$
\Gamma(\alpha)= (\alpha -1)\Gamma(\alpha -1)
$$
A função de distribuição de densidade gama pode ser descrita como:
$$
p(x)=x^{k-1} \frac{e^{-x/\theta}}{\theta^{k}\Gamma(k)},
$$
Onde $k$ é a forma, $\theta$ é a escala e $\Gamma$ é a função gama.
End of explanation
"""


mu, sigma = 3., 1. # mean and standard deviation
s = np.random.lognormal(mu, sigma, 1000)

count, bins, ignored = plt.hist(s, 100, normed=True, align='mid')




x = np.linspace(min(bins), max(bins), 10000)
pdf = (np.exp(-(np.log(x) - mu)**2 / (2 * sigma**2))
       / (x * sigma * np.sqrt(2 * np.pi)))


plt.plot(x, pdf, linewidth=2, color='r')
plt.axis('tight')
plt.show()


"""
Explanation: https://docs.scipy.org/doc/numpy/reference/generated/numpy.random.RandomState.standard_gamma.html#numpy.random.RandomState.standard_gamma

<font size="4px" font color="black" face="Times New Roman"><b>II- A Distribuição Logarítimica Normal</b></font>
A variável $x$ tem uma distribuição log-normal se $f(x)$ está normalmente distribuída. Neste caso, a função densidade de probabilidade para a distribuição log-normal é:
$$
p(x)= \frac{1}{\sigma x \sqrt{2 \pi}} e^{(-\frac{(ln(x)-\mu)^{2}}{2\sigma^{2}})}
$$
Onde $\sigma$ é a média, $\sigma$ é o desvio padrão de uma distribuição normal logarítimica.
End of explanation
"""


#Gerando números aleatórios
a = .6
s = np.random.logseries(a, 10000)
count, bins, ignored = plt.hist(s)

#Calculando a probabilidade
def logseries(k, p):
    return -p**k/(k*log(1-p))

plt.plot(bins, logseries(bins, a)*count.max()/
         logseries(bins, a).max(), 'r')
plt.show()

"""
Explanation: https://docs.scipy.org/doc/numpy/reference/generated/numpy.random.RandomState.lognormal.html#numpy.random.RandomState.lognormal

<font size="4px" font color="black" face="Times New Roman"><b>III- A Distribuição de Série Logarítimica</b></font>
A densidade de probabilidade de uma distribuição em série logarítimica é dada por:
$$
p(k)=\frac{-p^{k}}{k\ln(1-p)},
$$
Onde $p$ é a probabilidade.
End of explanation
"""


a, m = 3., 2.  # shape and mode
s = (np.random.pareto(a, 10000) + 1) * m


count, bins, _ = plt.hist(s, 100, normed=True)
fit = a*m**a / bins**(a+1)
plt.plot(bins, max(count)*fit/max(fit), linewidth=2, color='r')
plt.show()


"""
Explanation: https://docs.scipy.org/doc/numpy/reference/generated/numpy.random.RandomState.logseries.html#numpy.random.RandomState.logseries

<font size="4px" font color="black" face="Times New Roman"><b>IV- A Distribuição de Pareto</b></font>
A probabilidade de densidade para a distribuição de pareto é dada por:
$$
p(x)=\frac{am^{a}}{x^{a+1}},
$$
Onde $a$ é forma da função e $m$ é a escala.
Umas das aplicações da distribuição estatística de Pareto foi a utilização para o cálculo do tamanho de campos de óleo.
End of explanation
"""


np.random.random_integers(5)

type(np.random.random_integers(5))

np.random.random_integers(5, size=(3.,2.))

2.5 * (np.random.random_integers(5, size=(5,)) - 1) / 4.

d1 = np.random.random_integers(1, 6, 1000)
d2 = np.random.random_integers(1, 6, 1000)
dsums = d1 + d2

count, bins, ignored = plt.hist(dsums, 11, normed=True)
plt.show()

"""
Explanation: https://docs.scipy.org/doc/numpy/reference/generated/numpy.random.RandomState.pareto.html#numpy.random.RandomState.pareto

<font size="4px" font color="black" face="Times New Roman"><b>V- Integradores Radômicos</b></font>
Geram números aleatórios de uma distribuição discreta e uniforme no intervalo definido entre [valorbaixo, valoralto]. Caso o [valoralto=vazio] então o resultado vai variar de [valorbaixo,1].
$$
a + (b - a) * (np.random.random__integers(N) - 1) / (N - 1.)
$$
End of explanation
"""


