import numpy as np
import matplotlib.pyplot as plt
import seaborn as sns
import random
import math


class Poisson:
    def __init__(self, lmbda, noMuestras):
        self.lmbda = lmbda
        self.noMuestras = noMuestras
        self.muestras = [0]*noMuestras
    
    """
    Method --simula()
    Método para crear las muestras a simular.
    """
    def simula(self):
        muestras = [0]*self.noMuestras
        for j in range(0,self.noMuestras):
            muestras[j] = self.poisson()
        return muestras
    
    """
    Method (auxiliar) -- poisson()
    @return x: Dondé X es una variable aleatoria que se distribuye Poisson.
    Método auxiliar para crear una una variable aleatoria que se destribuye Poisson.
    """

    def poisson(self):
        x = 0
        u = random.uniform(0,1)
        p = math.exp(-1*self.lmbda)
        F = p
        i = 0
        while(True):
            if u < F:
                x = i
                break
            i += 1
            p = (self.lmbda*p)/(i)
            F = F + p
        return x
    """
    Method -- presentaMuestras()
    Método para mejorar la representación de cadena del arreglo de muestras.
    """
    def presentaMuestras(self):
        self.muestras = self.simula()
        n = len(self.muestras) #longitud del arreglo
        s = "[ "
        j = 0
        if n == 0:
            return s + "]"
        for i in range(0,n):
            if i == n-1:
                s = s + str.format("%.2f" % self.muestras[i]) + " ]"
            else:
                if j == 15:
                    s = s + str.format("%.2f" % self.muestras[i]) + ", \n  "
                    j = 0
                else:
                    s = s + str.format("%.2f" % self.muestras[i]) + ", "
                    j += 1
        print(s)

    """
    Method -- grafica()
    Método para graficar las muestras, haciendo uso del módulo seaborn de python.
    """
    def grafica(self):
        if len(self.muestras) > 1:
            ax = sns.distplot(self.muestras,
                    kde=True,
                    bins=100,
                    color='skyblue',
                    hist_kws={"linewidth": 15,'alpha':1})
            ax.set(xlabel='Poisson Distribution', ylabel='Frequency')
            plt.show()


052870a5ce530de4c4de3f3bcfd7c2f13cdec525
<mask token>


class Poisson:

    def __init__(self, lmbda, noMuestras):
        self.lmbda = lmbda
        self.noMuestras = noMuestras
        self.muestras = [0] * noMuestras
    <mask token>

    def simula(self):
        muestras = [0] * self.noMuestras
        for j in range(0, self.noMuestras):
            muestras[j] = self.poisson()
        return muestras
    <mask token>

    def poisson(self):
        x = 0
        u = random.uniform(0, 1)
        p = math.exp(-1 * self.lmbda)
        F = p
        i = 0
        while True:
            if u < F:
                x = i
                break
            i += 1
            p = self.lmbda * p / i
            F = F + p
        return x
    <mask token>
    <mask token>
    <mask token>

    def grafica(self):
        if len(self.muestras) > 1:
            ax = sns.distplot(self.muestras, kde=True, bins=100, color=
                'skyblue', hist_kws={'linewidth': 15, 'alpha': 1})
            ax.set(xlabel='Poisson Distribution', ylabel='Frequency')
            plt.show()

<mask token>


class Poisson:

    def __init__(self, lmbda, noMuestras):
        self.lmbda = lmbda
        self.noMuestras = noMuestras
        self.muestras = [0] * noMuestras
    <mask token>

    def simula(self):
        muestras = [0] * self.noMuestras
        for j in range(0, self.noMuestras):
            muestras[j] = self.poisson()
        return muestras
    <mask token>

    def poisson(self):
        x = 0
        u = random.uniform(0, 1)
        p = math.exp(-1 * self.lmbda)
        F = p
        i = 0
        while True:
            if u < F:
                x = i
                break
            i += 1
            p = self.lmbda * p / i
            F = F + p
        return x
    <mask token>

    def presentaMuestras(self):
        self.muestras = self.simula()
        n = len(self.muestras)
        s = '[ '
        j = 0
        if n == 0:
            return s + ']'
        for i in range(0, n):
            if i == n - 1:
                s = s + str.format('%.2f' % self.muestras[i]) + ' ]'
            elif j == 15:
                s = s + str.format('%.2f' % self.muestras[i]) + ', \n  '
                j = 0
            else:
                s = s + str.format('%.2f' % self.muestras[i]) + ', '
                j += 1
        print(s)
    <mask token>

    def grafica(self):
        if len(self.muestras) > 1:
            ax = sns.distplot(self.muestras, kde=True, bins=100, color=
                'skyblue', hist_kws={'linewidth': 15, 'alpha': 1})
            ax.set(xlabel='Poisson Distribution', ylabel='Frequency')
            plt.show()

<mask token>


class Poisson:

    def __init__(self, lmbda, noMuestras):
        self.lmbda = lmbda
        self.noMuestras = noMuestras
        self.muestras = [0] * noMuestras
    """
    Method --simula()
    Método para crear las muestras a simular.
    """

    def simula(self):
        muestras = [0] * self.noMuestras
        for j in range(0, self.noMuestras):
            muestras[j] = self.poisson()
        return muestras
    """
    Method (auxiliar) -- poisson()
    @return x: Dondé X es una variable aleatoria que se distribuye Poisson.
    Método auxiliar para crear una una variable aleatoria que se destribuye Poisson.
    """

    def poisson(self):
        x = 0
        u = random.uniform(0, 1)
        p = math.exp(-1 * self.lmbda)
        F = p
        i = 0
        while True:
            if u < F:
                x = i
                break
            i += 1
            p = self.lmbda * p / i
            F = F + p
        return x
    """
    Method -- presentaMuestras()
    Método para mejorar la representación de cadena del arreglo de muestras.
    """

    def presentaMuestras(self):
        self.muestras = self.simula()
        n = len(self.muestras)
        s = '[ '
        j = 0
        if n == 0:
            return s + ']'
        for i in range(0, n):
            if i == n - 1:
                s = s + str.format('%.2f' % self.muestras[i]) + ' ]'
            elif j == 15:
                s = s + str.format('%.2f' % self.muestras[i]) + ', \n  '
                j = 0
            else:
                s = s + str.format('%.2f' % self.muestras[i]) + ', '
                j += 1
        print(s)
    """
    Method -- grafica()
    Método para graficar las muestras, haciendo uso del módulo seaborn de python.
    """

    def grafica(self):
        if len(self.muestras) > 1:
            ax = sns.distplot(self.muestras, kde=True, bins=100, color=
                'skyblue', hist_kws={'linewidth': 15, 'alpha': 1})
            ax.set(xlabel='Poisson Distribution', ylabel='Frequency')
            plt.show()

import numpy as np
import matplotlib.pyplot as plt
import seaborn as sns
import random
import math


class Poisson:

    def __init__(self, lmbda, noMuestras):
        self.lmbda = lmbda
        self.noMuestras = noMuestras
        self.muestras = [0] * noMuestras
    """
    Method --simula()
    Método para crear las muestras a simular.
    """

    def simula(self):
        muestras = [0] * self.noMuestras
        for j in range(0, self.noMuestras):
            muestras[j] = self.poisson()
        return muestras
    """
    Method (auxiliar) -- poisson()
    @return x: Dondé X es una variable aleatoria que se distribuye Poisson.
    Método auxiliar para crear una una variable aleatoria que se destribuye Poisson.
    """

    def poisson(self):
        x = 0
        u = random.uniform(0, 1)
        p = math.exp(-1 * self.lmbda)
        F = p
        i = 0
        while True:
            if u < F:
                x = i
                break
            i += 1
            p = self.lmbda * p / i
            F = F + p
        return x
    """
    Method -- presentaMuestras()
    Método para mejorar la representación de cadena del arreglo de muestras.
    """

    def presentaMuestras(self):
        self.muestras = self.simula()
        n = len(self.muestras)
        s = '[ '
        j = 0
        if n == 0:
            return s + ']'
        for i in range(0, n):
            if i == n - 1:
                s = s + str.format('%.2f' % self.muestras[i]) + ' ]'
            elif j == 15:
                s = s + str.format('%.2f' % self.muestras[i]) + ', \n  '
                j = 0
            else:
                s = s + str.format('%.2f' % self.muestras[i]) + ', '
                j += 1
        print(s)
    """
    Method -- grafica()
    Método para graficar las muestras, haciendo uso del módulo seaborn de python.
    """

    def grafica(self):
        if len(self.muestras) > 1:
            ax = sns.distplot(self.muestras, kde=True, bins=100, color=
                'skyblue', hist_kws={'linewidth': 15, 'alpha': 1})
            ax.set(xlabel='Poisson Distribution', ylabel='Frequency')
            plt.show()

import numpy as np
import matplotlib.pyplot as plt
import seaborn as sns
import random
import math


class Poisson:
    def __init__(self, lmbda, noMuestras):
        self.lmbda = lmbda
        self.noMuestras = noMuestras
        self.muestras = [0]*noMuestras
    
    """
    Method --simula()
    Método para crear las muestras a simular.
    """
    def simula(self):
        muestras = [0]*self.noMuestras
        for j in range(0,self.noMuestras):
            muestras[j] = self.poisson()
        return muestras
    
    """
    Method (auxiliar) -- poisson()
    @return x: Dondé X es una variable aleatoria que se distribuye Poisson.
    Método auxiliar para crear una una variable aleatoria que se destribuye Poisson.
    """

    def poisson(self):
        x = 0
        u = random.uniform(0,1)
        p = math.exp(-1*self.lmbda)
        F = p
        i = 0
        while(True):
            if u < F:
                x = i
                break
            i += 1
            p = (self.lmbda*p)/(i)
            F = F + p
        return x
    """
    Method -- presentaMuestras()
    Método para mejorar la representación de cadena del arreglo de muestras.
    """
    def presentaMuestras(self):
        self.muestras = self.simula()
        n = len(self.muestras) #longitud del arreglo
        s = "[ "
        j = 0
        if n == 0:
            return s + "]"
        for i in range(0,n):
            if i == n-1:
                s = s + str.format("%.2f" % self.muestras[i]) + " ]"
            else:
                if j == 15:
                    s = s + str.format("%.2f" % self.muestras[i]) + ", \n  "
                    j = 0
                else:
                    s = s + str.format("%.2f" % self.muestras[i]) + ", "
                    j += 1
        print(s)

    """
    Method -- grafica()
    Método para graficar las muestras, haciendo uso del módulo seaborn de python.
    """
    def grafica(self):
        if len(self.muestras) > 1:
            ax = sns.distplot(self.muestras,
                    kde=True,
                    bins=100,
                    color='skyblue',
                    hist_kws={"linewidth": 15,'alpha':1})
            ax.set(xlabel='Poisson Distribution', ylabel='Frequency')
            plt.show()

