<file_sep>from random import randint
import numpy as np
import pandas as pd
import matplotlib.pyplot as plt

min_ruleta = 0
max_ruleta = 36
numeros_ruleta = 37.0
verde = 0
max_tiradas = 35
corridas_programa = 10
estrategia_multiplicador = {
    'rojos': 2, 
    'pares': 2,
    'docenas': 3,
    'columnas': 3,
    'pleno': 35,
}

def get_pares(pares, i):
    if i%2 == 0:
        pares.append(i)
    return pares

def get_impares(impares, i):
    if i%2 != 0:
        impares.append(i)
    return impares

def get_docenas(docenas, i):
    if i<=12:
        docenas[0].append(i)
    elif i>12 and i<= 24:
        docenas[1].append(i)
    elif i>24:
        docenas[2].append(i)
    return docenas

def get_columnas(columnas):
    col_in = 1
    while col_in <= 34:
        columnas[0].append(col_in)
        col_in = col_in+3
    col_in = 2
    while col_in <= 35:
        columnas[1].append(col_in)
        col_in = col_in+3
    col_in = 3
    while col_in <= 36:
        columnas[2].append(col_in)
        col_in = col_in+3
    return columnas

def ini_ruleta():
    rojos = [1, 3, 5, 7, 9, 12, 14, 16, 18, 19, 21, 23, 25, 27, 30, 32, 34, 36]
    negros = [2, 4, 6, 8, 10, 11, 13, 15, 17, 20, 22, 24, 26, 28, 29, 31, 33, 35]
    pares = []
    impares = []
    docenas = [[],[],[]]
    columnas = [[],[],[]]
    columnas = get_columnas(columnas)
    for i in range(1,int(numeros_ruleta)):
        pares = get_pares(pares, i)
        impares = get_impares(impares, i)
        docenas = get_docenas(docenas, i)
    valores_ruleta = {
        'rojos': rojos, 
        'negros': negros,
        'pares': pares,
        'impares': impares,
        'docenas': docenas,
        'columnas': columnas,
    }
    return valores_ruleta


def girar_ruleta():
    tiros = randint(5, 150)
    for i in range(0,tiros):
        resultado = randint(min_ruleta, max_ruleta)
    return resultado

def get_apuesta_deseada(fondos):
    apuesta_validada = -1
    while (apuesta_validada < 0 or apuesta_validada > fondos):
        apuesta_deseada = float(input("Ingresa tu apuesta: $"))
        if (apuesta_deseada > 0 and apuesta_deseada <= fondos):
            apuesta_validada = apuesta_deseada
    return apuesta_deseada

def get_lista_resultados_deseados():
    resultados_deseados = []
    resultados_deseados_validado = -1
    while (resultados_deseados_validado < 0 or resultados_deseados_validado > max_ruleta):
        res_des = int(input("Resultado deseado: "))
        resultados_deseados.append(res_des)
        if (resultados_deseados[0] > 0 and resultados_deseados[0] <= max_ruleta):
            resultados_deseados_validado = resultados_deseados[0]
    return resultados_deseados


def apuesta_simple(capital_inicial, apuesta_actual, resultados_deseados, multiplicador):
    resultados = []
    fondos = capital_inicial
    conteo_giros = 0
    while conteo_giros < max_tiradas:
        if fondos < apuesta_actual:
            resultados.append({'valor': None, 'caja': fondos})
        else:
            fondos -= apuesta_actual
            resultado_obtenido = girar_ruleta()
            if (resultado_obtenido in resultados_deseados):
                fondos+= apuesta_actual*multiplicador
            resultados.append({'valor': resultado_obtenido, 'caja': fondos})
        conteo_giros += 1
    return resultados

def martin_gala(fondos, apuesta_base, resultados_deseados, multiplicador):
    resultados = []
    apuesta_actual = apuesta_base
    conteo_giros = 0
    while conteo_giros < max_tiradas:
        if fondos < apuesta_actual:
            resultados.append({'valor': None, 'caja': fondos})
        else:
            fondos = fondos - apuesta_actual
            resultado_obtenido = girar_ruleta()
            if (resultado_obtenido in resultados_deseados):
                premio = apuesta_actual*multiplicador
                fondos = fondos + premio
                apuesta_actual = apuesta_base
            else:
                apuesta_actual = apuesta_actual * 2
            resultados.append({'valor': resultado_obtenido, 'caja': fondos})
        conteo_giros += 1
    return resultados


# En la fibonacci, 1, 1, 2, 3, 5, 8, 13, 21, 34, ...

def calcular_fib(n):
    if n < 2:
        return n
    else:
        return calcular_fib(n-1) + calcular_fib(n-2)

def fibonacci(fondos, apuesta_base, resultados_deseados, multiplicador):
    resultados_fibo = []
    apuesta_actual = apuesta_base
    fib_index_actual = 1
    valor_fib_actual = 1
    conteo_giros = 0
    
    while conteo_giros < max_tiradas:
        if fondos < apuesta_actual:
            resultados_fibo.append({'valor': None, 'caja': fondos})
        else:
            fondos = fondos - apuesta_actual
            resultado_obtenido = girar_ruleta()
            if (resultado_obtenido in resultados_deseados):
                premio = apuesta_actual*multiplicador
                fondos = fondos + premio
                if fib_index_actual < 2:
                    fib_index_actual = 1
                else:
                    fib_index_actual = fib_index_actual - 1
                valor_fib_actual = calcular_fib(fib_index_actual)
                apuesta_actual = apuesta_base * valor_fib_actual
            else:
                fib_index_actual = fib_index_actual + 1
                valor_fib_actual = calcular_fib(fib_index_actual)
                apuesta_actual = apuesta_base * valor_fib_actual
            resultados_fibo.append({'valor': resultado_obtenido, 'caja': fondos})
        conteo_giros += 1
    return resultados_fibo



def start_ruleta(ruleta):
    # ingreso fondos y valido, si es 0 el capital tiene que ser infinito
    fondos = float(input("Ingrese el capital total (0, si desea capital infinito): $"))
    while fondos < 0:
        fondos = float(input("Ingrese el capital total: "))
    if fondos == 0:
        fondos = 99999999999

    # ingreso y valido cantidad a apostar.
    apuesta_actual = get_apuesta_deseada(fondos)

    pleno_deseado = get_lista_resultados_deseados()
    
    # ingreso estrategia de apuesta

    resultados_deseados_rojos = []
    resultados_rojos_as = []
    resultados_rojos_mg = []
    resultados_rojos_fi = []

    resultados_deseados_pares = []
    resultados_pares_as = []
    resultados_pares_mg = []
    resultados_pares_fi = []

    resultados_deseados_docenas = []
    resultados_docenas_as = []
    resultados_docenas_mg = []
    resultados_docenas_fi = []

    resultados_deseados_columnas = []
    resultados_columnas_as = []
    resultados_columnas_mg = []
    resultados_columnas_fi = []

    resultados_deseados_plenos = []
    resultados_plenos_as = []
    resultados_plenos_mg = []
    resultados_plenos_fi = []


    for i in range(0, corridas_programa):

        resultados_deseados = ruleta.get('rojos')
        ap = apuesta_simple(fondos, apuesta_actual, resultados_deseados, estrategia_multiplicador.get('rojos'))
        mg = martin_gala(fondos, apuesta_actual, resultados_deseados, estrategia_multiplicador.get('rojos'))
        fi = fibonacci(fondos, apuesta_actual, resultados_deseados, estrategia_multiplicador.get('rojos'))

        resultados_deseados_rojos.append(resultados_deseados)
        resultados_rojos_as.append(ap)
        resultados_rojos_mg.append(mg)
        resultados_rojos_fi.append(fi)


        resultados_deseados = ruleta.get('pares')
        ap = apuesta_simple(fondos, apuesta_actual, resultados_deseados, estrategia_multiplicador.get('pares'))
        mg = martin_gala(fondos, apuesta_actual, resultados_deseados, estrategia_multiplicador.get('pares'))
        fi = fibonacci(fondos, apuesta_actual, resultados_deseados, estrategia_multiplicador.get('pares'))

        resultados_deseados_pares.append(resultados_deseados)
        resultados_pares_as.append(ap)
        resultados_pares_mg.append(mg)
        resultados_pares_fi.append(fi)


        resultados_deseados = ruleta.get('docenas')[0]
        ap = apuesta_simple(fondos, apuesta_actual, resultados_deseados, estrategia_multiplicador.get('docenas'))
        mg = martin_gala(fondos, apuesta_actual, resultados_deseados, estrategia_multiplicador.get('docenas'))
        fi = fibonacci(fondos, apuesta_actual, resultados_deseados, estrategia_multiplicador.get('docenas'))

        resultados_deseados_docenas.append(resultados_deseados)
        resultados_docenas_as.append(ap)
        resultados_docenas_mg.append(mg)
        resultados_docenas_fi.append(fi)

        resultados_deseados = ruleta.get('columnas')[0]
        ap = apuesta_simple(fondos, apuesta_actual, resultados_deseados, estrategia_multiplicador.get('columnas'))
        mg = martin_gala(fondos, apuesta_actual, resultados_deseados, estrategia_multiplicador.get('columnas'))
        fi = fibonacci(fondos, apuesta_actual, resultados_deseados, estrategia_multiplicador.get('columnas'))

        resultados_deseados_columnas.append(resultados_deseados)
        resultados_columnas_as.append(ap)
        resultados_columnas_mg.append(mg)
        resultados_columnas_fi.append(fi)


        resultados_deseados = pleno_deseado
        ap = apuesta_simple(fondos, apuesta_actual, resultados_deseados, estrategia_multiplicador.get('pleno'))
        mg = martin_gala(fondos, apuesta_actual, resultados_deseados, estrategia_multiplicador.get('pleno'))
        fi = fibonacci(fondos, apuesta_actual, resultados_deseados, estrategia_multiplicador.get('pleno'))

        resultados_deseados_plenos.append(resultados_deseados)
        resultados_plenos_as.append(ap)
        resultados_plenos_mg.append(mg)
        resultados_plenos_fi.append(fi)

    retorno = {
    'resultados_deseados_rojos': resultados_deseados_rojos,
    'resultados_rojos_as': resultados_rojos_as,
    'resultados_rojos_mg': resultados_rojos_mg,
    'resultados_rojos_fi': resultados_rojos_fi,
    'resultados_deseados_pares': resultados_deseados_pares,
    'resultados_pares_as': resultados_pares_as,
    'resultados_pares_mg': resultados_pares_mg,
    'resultados_pares_fi': resultados_pares_fi,
    'resultados_deseados_docenas': resultados_deseados_docenas,
    'resultados_docenas_as': resultados_docenas_as,
    'resultados_docenas_mg': resultados_docenas_mg,
    'resultados_docenas_fi': resultados_docenas_fi,
    'resultados_deseados_columnas': resultados_deseados_columnas,
    'resultados_columnas_as': resultados_columnas_as,
    'resultados_columnas_mg': resultados_columnas_mg,
    'resultados_columnas_fi': resultados_columnas_fi,
    'resultados_deseados_plenos': resultados_deseados_plenos,
    'resultados_plenos_as': resultados_plenos_as,
    'resultados_plenos_mg': resultados_plenos_mg,
    'resultados_plenos_fi': resultados_plenos_fi,
    'fondos': fondos
    }


    return retorno


def get_fr_obtenida(resultados, resultados_posibles):
    resultados_filtrados = []
    for objeto in resultados:
        resultados_filtrados.append(objeto.get('valor'))
    veces_obtenido_resultado_deseado = 0
    for x in resultados_posibles:
        veces_obtenido_resultado_deseado += resultados_filtrados.count(x)
    cantidad_tiros = len(resultados)
    return float(float(veces_obtenido_resultado_deseado)/float(cantidad_tiros))


def get_valor_fondos(resultado):
    fondo = resultado.get('caja')
    return float(fondo)


def graficar(valores_obtenidos, fondos_iniciales):
    resultados_deseados_rojos = valores_obtenidos.get('resultados_deseados_rojos')
    resultados_rojos_as = valores_obtenidos.get('resultados_rojos_as')
    resultados_rojos_mg = valores_obtenidos.get('resultados_rojos_mg')
    resultados_rojos_fi = valores_obtenidos.get('resultados_rojos_fi')

    resultados_deseados_pares = valores_obtenidos.get('resultados_deseados_pares')
    resultados_pares_as = valores_obtenidos.get('resultados_pares_as')
    resultados_pares_mg = valores_obtenidos.get('resultados_pares_mg')
    resultados_pares_fi = valores_obtenidos.get('resultados_pares_fi')

    resultados_deseados_docenas = valores_obtenidos.get('resultados_deseados_docenas')
    resultados_docenas_as = valores_obtenidos.get('resultados_docenas_as')
    resultados_docenas_mg = valores_obtenidos.get('resultados_docenas_mg')
    resultados_docenas_fi = valores_obtenidos.get('resultados_docenas_fi')

    resultados_deseados_columnas = valores_obtenidos.get('resultados_deseados_columnas')
    resultados_columnas_as = valores_obtenidos.get('resultados_columnas_as')
    resultados_columnas_mg = valores_obtenidos.get('resultados_columnas_mg')
    resultados_columnas_fi = valores_obtenidos.get('resultados_columnas_fi')

    resultados_deseados_plenos = valores_obtenidos.get('resultados_deseados_plenos')
    resultados_plenos_as = valores_obtenidos.get('resultados_plenos_as')
    resultados_plenos_mg = valores_obtenidos.get('resultados_plenos_mg')
    resultados_plenos_fi = valores_obtenidos.get('resultados_plenos_fi')

    get_graficos(resultados_rojos_as, resultados_deseados_rojos, "rojos apuesta simple F.I: $"+str(fondos_iniciales))
    get_graficos(resultados_rojos_mg, resultados_deseados_rojos, "rojos martin gala F.I: $"+str(fondos_iniciales))
    get_graficos(resultados_rojos_fi, resultados_deseados_rojos, "rojos fibonacci F.I: $"+str(fondos_iniciales))

    get_graficos(resultados_pares_as, resultados_deseados_pares, "pares apuesta simple F.I: $"+str(fondos_iniciales))
    get_graficos(resultados_pares_mg, resultados_deseados_pares, "pares martin gala F.I: $"+str(fondos_iniciales))
    get_graficos(resultados_pares_fi, resultados_deseados_pares, "pares fibonacci F.I: $"+str(fondos_iniciales))

    get_graficos(resultados_docenas_as, resultados_deseados_docenas, "docenas apuesta simple F.I: $"+str(fondos_iniciales))
    get_graficos(resultados_docenas_mg, resultados_deseados_docenas, "docenas martin gala F.I: $"+str(fondos_iniciales))
    get_graficos(resultados_docenas_fi, resultados_deseados_docenas, "docenas fibonacci F.I: $"+str(fondos_iniciales))

    get_graficos(resultados_columnas_as, resultados_deseados_columnas, "columnas apuesta simple F.I: $"+str(fondos_iniciales))
    get_graficos(resultados_columnas_mg, resultados_deseados_columnas, "columnas martin gala F.I: $"+str(fondos_iniciales))
    get_graficos(resultados_columnas_fi, resultados_deseados_columnas, "columnas fibonacci F.I: $"+str(fondos_iniciales))

    get_graficos(resultados_plenos_as, resultados_deseados_plenos, "plenos apuesta simple F.I: $"+str(fondos_iniciales))
    get_graficos(resultados_plenos_mg, resultados_deseados_plenos, "plenos martin gala F.I: $"+str(fondos_iniciales))
    get_graficos(resultados_plenos_fi, resultados_deseados_plenos, "plenos fibonacci F.I: $"+str(fondos_iniciales))



def get_graficos(resultados, resultados_posibles, nombre_archivo):
    lista_de_fr = []
    lista_de_fondos = []

    #corridas para obtener valores
    for i in range(0, corridas_programa):
    
        lista_de_lista_de_resultados = []
        fr_obtenidas = []
        fondos_obtenidos = []

        for y in range(1, max_tiradas+1):
            temporal_lista  = []
            fondos_obtenidos.append(get_valor_fondos(resultados[i][y-1]))

            #analiza resultados incrementalmente
            for x in range(0, y):
                temporal_lista.append(resultados[i][x])
            lista_de_lista_de_resultados.append(temporal_lista)
            fr_obtenidas.append(get_fr_obtenida(lista_de_lista_de_resultados[y-1], resultados_posibles[0]))

        lista_de_fr.append(fr_obtenidas)
        lista_de_fondos.append(fondos_obtenidos)



    #para grafica de resultados    
    tiradas = []
    for i in range(1, max_tiradas+1):
        tiradas.append(i)

    #armado de graficos
    get_grafico_fr(tiradas, lista_de_fr, nombre_archivo)
    get_grafico_fondos(tiradas, lista_de_fondos, nombre_archivo)


def get_grafico_fr(tiradas, lista_de_fr, nombre_archivo):
    df = pd.DataFrame(columns=tiradas, data=lista_de_fr)
    
    print(df)

    names = []
    cantidad_de_lineas = len(lista_de_fr)
    for i in range(0, cantidad_de_lineas):
            names.append('FR ' + str(i+1))

    df = df.set_index([names])

    df.T.plot()
    plt.xlabel("Tiradas")
    plt.ylabel("Frecuencias relativas")
    plt.title("Grafico frecuencias relativas "+str(nombre_archivo))
    plt.savefig("grafico-fr-relativas-"+str(nombre_archivo)+".svg")


def get_grafico_fondos(tiradas, lista_de_valores, nombre_archivo):
    df = pd.DataFrame(columns=tiradas, data=lista_de_valores)
    
    print(df)

    names = []
    cantidad_de_lineas = len(lista_de_valores)
    for i in range(0, cantidad_de_lineas):
            names.append('Fondos ' + str(i+1))

    df = df.set_index([names])

    df.T.plot()
    plt.xlabel("Numero de tirada")
    plt.ylabel("Fondo en $")
    plt.title("Grafico fondos "+str(nombre_archivo))
    plt.savefig("grafico-fondos-"+str(nombre_archivo)+".svg")



def main():
    # creo la ruleta y la inicializo
    ruleta = ini_ruleta()
    # inicio el juego
    valores_obtenidos = start_ruleta(ruleta)
    fondos = valores_obtenidos.get('fondos')
    if fondos == 99999999999:
        fondos = 'infinito'
    else:
        fondos = str(fondos)
    graficar(valores_obtenidos, fondos)

if __name__ == "__main__":
    main()<file_sep>from random import uniform, randint
from math import log

smalls_list = [20, 20, 20, 20, 40, 40, 40, 60, 60]
bigs_list = [40, 60, 80, 100, 60, 80, 100, 80, 100]

#int
amount = 0
bigs = 0
initial_inv_level = 60
inv_level = 0
next_event_type = 0
num_events = 0
num_months = 120
num_values_demand = 4
smalls = 0

#float
area_holding = 0.0
area_shortage = 0.0
holding_cost = 1.0
incremental_cost = 3.0
maxlag = 1.0
mean_interdemand = 0.10
minlag = 0.5
setup_cost = 32.0
shortage_cost = 5.0
time = 0.0
time_last_event = 0.0
total_ordering_cost = 0.0

prob_distrib_demand = [0.0, 0.167, 0.500, 0.833, 1000];

y = 0
time_next_event = [];
while (y < 5):
    time_next_event.append(0.0);
    y = y+1


def main():
    global num_events, next_event_type, smalls, bigs, smalls_list, bigs_list, time

    num_policies = 9

    num_events = 4


    print "Single-product inventory system"; 
    print('')
    print('')
    print "Initial inventory level items: ", initial_inv_level;
    print "Number of demand sizes: ", num_values_demand;
    print "Distribution function of demand sizes: ", prob_distrib_demand[0], " ", prob_distrib_demand[1], " ", prob_distrib_demand[2], " ", prob_distrib_demand[3], " ", prob_distrib_demand[4], " "
    print "Mean interdemand time: ", mean_interdemand, " months"
    print "Delivery lag range: ", minlag, " months to ", maxlag, " months"
    print "Length of the simulation ", num_months, " months"
    print "K = ", setup_cost, " , i = ", incremental_cost, " , h = ", holding_cost, " , pi = ", shortage_cost
    print "Number of policies ", num_policies
    print('')
    print('')
    print("Policy  ---- Average Total Cost ---- Average ordering cost ---- Average holding cost ---- Average shortage cost ")

    for i in range(0, num_policies):
        smalls = smalls_list[i]
        bigs = bigs_list[i]
        initialize();
        maybe_timing = timing();
        while (next_event_type != 3):
            maybe_timing = timing();
            if maybe_timing == -9999999999999999999999999999999:
                break
            else:
                time = maybe_timing
            update_time_avg_stats();

            if next_event_type == 1:
                order_arrival()
            elif next_event_type == 2:
                demand()
            elif next_event_type == 4:
                evaluate()
        report()
        

def initialize():
    global time, inv_level, initial_inv_level, time_last_event, total_ordering_cost, area_holding, area_shortage, time_next_event, mean_interdemand, num_months

    time = 0.0

    inv_level = initial_inv_level
    time_last_event = 0.0

    total_ordering_cost = 0.0
    area_holding = 0.0
    area_shortage = 0.0

    time_next_event[0] = 0.0
    time_next_event[1] = 1000000000000000000000000000000.0
    time_next_event[2] = time + expon(mean_interdemand)
    time_next_event[3] = num_months
    time_next_event[4] = 0.0


def order_arrival():
    global inv_level, amount, time_next_event
    inv_level = inv_level + amount
    time_next_event[1] = 1000000000000000000000000000000.0


def demand():
    global prob_distrib_demand, inv_level, time_next_event, time, mean_interdemand
    size_demand = 0

    size_demand = random_integer(prob_distrib_demand)
    inv_level = inv_level - size_demand
    time_next_event[2] = time + expon(mean_interdemand)


def evaluate():
    global inv_level, smalls, bigs, amount, total_ordering_cost, setup_cost, incremental_cost, time_next_event, time, minlag, maxlag

    if inv_level < smalls:
        amount = bigs - inv_level
        total_ordering_cost = total_ordering_cost + setup_cost + (incremental_cost * amount)
        time_next_event[1] = time + local_uniform(minlag, maxlag)
    time_next_event[4] = time + 1.0


def report():
    global total_ordering_cost, num_months, holding_cost, area_holding, shortage_cost, area_shortage, smalls, bigs

    avg_holding_cost = 0.0
    avg_ordering_cost = 0.0
    avg_shortage_cost = 0.0
    avg_ordering_cost = total_ordering_cost / num_months
    avg_holding_cost = holding_cost * area_holding / num_months
    avg_shortage_cost = shortage_cost * area_shortage / num_months
    print '(', smalls, ', ', bigs, ') ---- ', avg_ordering_cost + avg_holding_cost + avg_shortage_cost, ' ---- ', avg_ordering_cost, ' ---- ', avg_holding_cost, ' ---- ', avg_shortage_cost


def expon(mean):
    u = uniform(0.0, 1.0)
    expon_number = -mean * log(u)
    return expon_number


def update_time_avg_stats():
    global time, time_last_event, inv_level, area_shortage, area_holding

    time_since_last_event = 0.0

    time_since_last_event = time - time_last_event
    time_last_event = time

    if (inv_level < 0):
        area_shortage = area_shortage - (inv_level * time_since_last_event)
    elif inv_level > 0:
        area_holding = area_holding + (inv_level * time_since_last_event)


def random_integer(prob_distrib):
    i = 1
    u = 0.0

    u = uniform(0, 1)

    while(u > prob_distrib[i]):
        i=i+1
    
    return i


def local_uniform(a, b):
    u = 0.0

    u = uniform(0, 1)

    return a + (u * (b-a))


def timing():
    global num_events, time_next_event, next_event_type
    i = 1
    min_time_next_event = 100000000000000000000000000000.0
    next_event_type = 0

    for i in range(1, num_events+1):
        if time_next_event[i] < min_time_next_event :
            min_time_next_event = time_next_event[i]
            next_event_type = i

    if next_event_type == 3:
        return -9999999999999999999999999999999
    return min_time_next_event;


if __name__ == "__main__":
    main()<file_sep>from random import randint
import numpy as np
import pandas as pd
import matplotlib.pyplot as plt


min_ruleta = 0
max_ruleta = 36
numeros_ruleta = 37.0
valor_estadistico_ruleta = 1.0/37.0
valor_promedio_esperado = 37.0/2.0

#fr = frecuencia relativa
#vp = valor promedio
#vd = valor desvio
#vv = valor varianza

def girar_ruleta(cantidad_giros):
    resultados = []
    for i in range(0,cantidad_giros):
        resultado = randint(min_ruleta, max_ruleta)
        resultados.append(resultado)
    return resultados


def get_fr_esperada():
    return valor_estadistico_ruleta


def get_vp_esperado(cantidad_giros):
    return float(valor_promedio_esperado)


def get_vd_esperado(cantidad_giros):
    valores_posibles = []
    for i in range(min_ruleta, max_ruleta):
        valores_posibles.append(i)
    lista = np.array(valores_posibles)
    return lista.std()
    

def get_vv_esperado(cantidad_giros):
    valores_posibles = []
    for i in range(min_ruleta, max_ruleta):
        valores_posibles.append(i)
    lista = np.array(valores_posibles)
    return lista.var()


def get_fr_obtenida(resultados, resultado_deseado):
    veces_obtenido_resultado_deseado = resultados.count(resultado_deseado)
    cantidad_tiros = len(resultados)
    return float(float(veces_obtenido_resultado_deseado)/float(cantidad_tiros))


def get_vp_obtenido(resultados):
    sumatoria_valores_obtenidos = 0
    for i in resultados:
        sumatoria_valores_obtenidos+=i
    return float(float(sumatoria_valores_obtenidos)/float(len(resultados)))


def get_vd_obtenido(resultados):
    lista = np.array(resultados)
    return lista.std()


def get_vv_obtenido(resultados):
    lista = np.array(resultados)
    return lista.var()


def get_grafico_resultados(tiradas, resultados_deseados, resultados):
    lista = []
    for i in range(0, len(resultados)):
        element = []
        element.append(resultados[i])
        element.append(resultados_deseados[i])
        element.append(tiradas[i])
        lista.append(element)
    df = pd.DataFrame(columns=['resultados', 'resultados deseados', 'tiradas'], index=tiradas, data=lista)
    ax1 = df.plot(kind='scatter', x='tiradas', y='resultados deseados', color='r', label="Resultado deseado")    
    ax2 = df.plot(kind='scatter', x='tiradas', y='resultados', color='g', ax=ax1, label="Resultado obtenido") 
    print(df)
    plt.xlabel("Tiradas")
    plt.ylabel("Valores")

    plt.title("Grafico resultados deseados vs obtenidos")
    plt.savefig("grafico-resultados-"+str(len(tiradas))+".svg")


def get_grafico_fr(tiradas, lista_de_fr):
    df = pd.DataFrame(columns=tiradas, data=lista_de_fr)
    
    print(df)

    names = []
    cantidad_de_lineas = len(lista_de_fr)
    for i in range(0, cantidad_de_lineas):
        if i == cantidad_de_lineas-1:
            names.append('Frecuencia relativa esperada')
        else:
            names.append('Frecuencia relativa ' + str(i+1) + ' obtenida')

    df = df.set_index([names])

    df.T.plot()
    plt.xlabel("Tiradas")
    plt.ylabel("Frecuencias relativas")
    plt.title("Grafico frecuencias relativas esperadas vs obtenidas")
    plt.savefig("grafico-fr-relativas-"+str(len(tiradas))+".svg")


def get_grafico_vp(tiradas, lista_de_vp):
    df = pd.DataFrame(columns=tiradas, data=lista_de_vp)
    
    print(df) 
    names = []
    cantidad_de_lineas = len(lista_de_vp)
    for i in range(0, cantidad_de_lineas):
        if i == cantidad_de_lineas-1:
            names.append('Valor promedio esperado')
        else:
            names.append('Valor promedio ' + str(i+1) + ' obtenido')
    df = df.set_index([names])

    df.T.plot()
    plt.xlabel("Tiradas")
    plt.ylabel("Valores promedio")
    plt.title("Grafico valores promedio esperados vs valores promedio obtenidos")
    plt.savefig("grafico-vp-"+str(len(tiradas))+".svg")


def get_grafico_vd(tiradas, lista_de_vd):
    df = pd.DataFrame(columns=tiradas, data=lista_de_vd)
    
    print(df) 
    names = []
    cantidad_de_lineas = len(lista_de_vd)
    for i in range(0, cantidad_de_lineas):
        if i == cantidad_de_lineas-1:
            names.append('Valor desvio esperado')
        else:
            names.append('Valor desvio ' + str(i+1) + ' obtenido')
    df = df.set_index([names])

    df.T.plot()
    plt.xlabel("Tiradas")
    plt.ylabel("Valor del desvio estandar")
    plt.title("Grafico valores desvio estandar esperados vs obtenidos")
    plt.savefig("grafico-vd-"+str(len(tiradas))+".svg")


def get_grafico_vv(tiradas, lista_de_vv):
    df = pd.DataFrame(columns=tiradas, data=lista_de_vv)
    
    print(df) 
    names = []
    cantidad_de_lineas = len(lista_de_vv)
    for i in range(0, cantidad_de_lineas):
        if i == cantidad_de_lineas-1:
            names.append('Valor varianza esperado')
        else:
            names.append('Valor varianza ' + str(i+1) + ' obtenido')
    df = df.set_index([names])

    df.T.plot()
    plt.xlabel("Tiradas")
    plt.ylabel("Valor de la varianza")
    plt.title("Grafico valores varianza esperados vs valores varianza obtenidos")
    plt.savefig("grafico-vv-"+str(len(tiradas))+".svg")


def jugar_ruleta(cantidad_giros, resultado_deseado, cantidad_de_corridas_para_comparar):
    lista_de_resultados = []
    lista_de_fr = []
    lista_de_vp = []
    lista_de_vd = []
    lista_de_vv = []


    #corridas para obtener valores
    for i in range(1, cantidad_de_corridas_para_comparar+1):
        resultados = girar_ruleta(cantidad_giros)
        lista_de_resultados.append(resultados)
    
        lista_de_lista_de_resultados = []
        fr_obtenidas = []
        vp_obtenidos = []
        vd_obtenidos = []
        vv_obtenidos = []
        for i in range(1, cantidad_giros+1):
            temporal_lista  = []

            #analiza resultados incrementalmente
            for x in range(0, i):
                temporal_lista.append(resultados[x])
            lista_de_lista_de_resultados.append(temporal_lista)
            fr_obtenidas.append(get_fr_obtenida(lista_de_lista_de_resultados[i-1], resultado_deseado))
            vp_obtenidos.append(get_vp_obtenido(lista_de_lista_de_resultados[i-1]))
            vd_obtenidos.append(get_vd_obtenido(lista_de_lista_de_resultados[i-1]))
            vv_obtenidos.append(get_vv_obtenido(lista_de_lista_de_resultados[i-1]))
        lista_de_fr.append(fr_obtenidas)
        lista_de_vp.append(vp_obtenidos)
        lista_de_vd.append(vd_obtenidos)
        lista_de_vv.append(vv_obtenidos)
        

    #valores esperados
    lista_de_lista_de_resultados = []
    fr_esperadas = []
    vp_esperados = []
    vd_esperados = []
    vv_esperados = []
    for i in range(1, cantidad_giros+1):
        fr_esperadas.append(get_fr_esperada())
        vp_esperados.append(get_vp_esperado(i))
        vd_esperados.append(get_vd_esperado(i))
        vv_esperados.append(get_vv_esperado(i))
    lista_de_fr.append(fr_esperadas)
    lista_de_vp.append(vp_esperados)
    lista_de_vd.append(vd_esperados)
    lista_de_vv.append(vv_esperados)



    #para grafica de resultados    
    tiradas = []
    resultados_deseados = []
    for i in range(1, cantidad_giros+1):
        tiradas.append(i)
        resultados_deseados.append(resultado_deseado)

    lista_de_resultados.append(resultados_deseados)

    #armado de graficos
    get_grafico_resultados(tiradas, resultados_deseados, resultados)
    get_grafico_fr(tiradas, lista_de_fr)
    get_grafico_vp(tiradas, lista_de_vp)
    get_grafico_vd(tiradas, lista_de_vd)
    get_grafico_vv(tiradas, lista_de_vv)


def main():
    cantidad_giros = int(input("Ingrese la cantidad de giros para la ruleta: "))
    resultado_deseado_verificado = -1
    while(resultado_deseado_verificado<0 or resultado_deseado_verificado>36):
        resultado_deseado = int(input("Ingrese el resultado deseado para la ruleta (entre 0 y 36): "))
        if resultado_deseado > 0 or resultado_deseado < 36:
            resultado_deseado_verificado = resultado_deseado

    cantidad_de_corridas_para_comparar = int(input("Ingrese la cantidad de corridas para la ruleta: "))
    jugar_ruleta(cantidad_giros, resultado_deseado_verificado, cantidad_de_corridas_para_comparar)


if __name__ == "__main__":
    main()<file_sep>from random import uniform
from math import log

def expon(mean):
    u = uniform(0.0, 1.0)
    expon_number = -mean * log(u)
    return expon_number


queue_limit = 100;
busy = 1;
idle = 0;
num_events = 2;

#mean interarrival time
mean_interarrival = 1 ;

#mean service time
mean_service = 0.5;

#number of customers
num_delays_required = 1000;

next_event_type = 0;
time_next_event = [0, 0, 0];

x = 0
time_arrival = [];
while (x < queue_limit):
    time_arrival.append(0);
    x = x+1

time = 0.0;
server_status = idle;
num_in_q = 0;
time_last_event = 0.0;
num_custs_delayed = 0;
total_of_delays = 0.0;
area_num_in_q = 0.0;
area_server_status = 0.0;
time_next_event[1] = time + expon(mean_interarrival)
time_next_event[2] = 1000000000000000000000000000000.0;


def main():
    global num_custs_delayed, num_delays_required, time, next_event_type, total_of_delays, area_num_in_q, area_server_status

    while num_custs_delayed < num_delays_required:
        maybe_time = timing()
        if (maybe_time == -9999999999999999999999999999999) :
            return
        time = maybe_time

        update_time_avg_stats()

        if next_event_type == 1:
            arrive()
        elif next_event_type == 2:
            depart()
    report()


def timing():
    global num_events, time_next_event, next_event_type
    i = 1
    min_time_next_event = 100000000000000000000000000000.0
    next_event_type = 0

    for i in range(1, num_events+1):
        if time_next_event[i] < min_time_next_event :
            min_time_next_event = time_next_event[i]
            next_event_type = i

    if next_event_type == 0:
        return -9999999999999999999999999999999
    return min_time_next_event;


def update_time_avg_stats():
    global time_last_event, area_num_in_q, area_server_status, time, num_in_q
    time_since_last_event = 0.0
    time_since_last_event = time - time_last_event
    time_last_event = time;
    area_num_in_q += num_in_q * time_since_last_event
    area_server_status += server_status * time_since_last_event


def arrive():
    global server_status, time_next_event, time, mean_interarrival, server_status, busy, num_in_q, queue_limit, time_arrival, total_of_delays, num_custs_delayed, mean_service
    delay = 0.0
    time_next_event[1] = time + expon(mean_interarrival)
    if (server_status == busy):
        num_in_q = num_in_q + 1
        if (num_in_q > queue_limit):
            print('Overflow of the array time_arrival at')
            print('Time: ', time)
            return
        time_arrival[num_in_q] = time
    else:
        delay = 0.0
        total_of_delays += delay

        num_custs_delayed = num_custs_delayed + 1
        server_status = busy

        time_next_event[2] = time + expon(mean_service)


def depart():
    global time_arrival, num_in_q, server_status, time_next_event, total_of_delays, num_custs_delayed, time, time_arrival, mean_service
    i = 1
    delay = 0.0

    if(num_in_q == 0):
        server_status = idle
        time_next_event[2] = 1000000000000000000000000000000.0
    else:
        num_in_q = num_in_q - 1
        delay = time - time_arrival[1]
        total_of_delays += delay
        num_custs_delayed = num_custs_delayed + 1
        time_next_event[2] = time + expon(mean_service)

    for i in range(1, num_in_q+1) :
        time_arrival[i] = time_arrival[i+1]


def report():
    global total_of_delays, num_custs_delayed, area_num_in_q, area_server_status, time
    print()
    print()
    if num_custs_delayed == 0:
        print('Average delay in queue in minutes: 0')
    else:
        print('Average delay in queue in minutes: ', total_of_delays / num_custs_delayed)
    print()
    print()
    if time == 0 or time == 0.0:
        print('Average number in queue: 0')
        print()
        print()
        print('Server utilization: 0')
    else:
        print('Average number in queue: ', area_num_in_q / time)
        print()
        print()
        print('Server utilization: ', area_server_status / time)
    print()
    print()
    print('Time simulation ended: ', time)
    print('-------------------------------------------------')


if __name__ == "__main__":
    main()