def __init__(self, pecaA, pecaB):
# Relógio de simulação - variável que contém o valor do tempo em cada instante
self.instant = 0 # valor inicial a zero
# Serviço - pode haver mais do que um num simulador
self.fila_envernizamento = fila.Fila(self, 'envernizamento', 30,
pecaA.n_servicos_envernizamento)
self.fila_polimento_A = fila.Fila(self, 'polimento', 45,
pecaA.n_servicos_polimento,
self.fila_envernizamento)
self.fila_polimento_B = fila.Fila(self, 'polimento', 60,
pecaB.n_servicos_polimento,
self.fila_envernizamento)
self.fila_perfuracao_A = fila.Fila(self, 'perfuracao', 75,
pecaA.n_servicos_perfuracao,
self.fila_polimento_A)
self.fila_perfuracao_B = fila.Fila(self, 'perfuracao', 90,
pecaB.n_servicos_perfuracao,
self.fila_polimento_B)
# Lista de eventos - onde ficam registados todos os eventos que vão ocorrer na simulação
# Cada simulador só tem uma
self.event_list = lista.Lista(self)
# Agendamento da primeira chegada
# Se n�o for feito, o simulador n�o tem eventos para simular
self.insereEvento(
eventos.Chegada(self.instant, self, self.fila_perfuracao_A, pecaA))
self.insereEvento(
eventos.Chegada(self.instant, self, self.fila_perfuracao_B, pecaB))
def __init__(self, m_cheg_a, m_cheg_b, n_sim, toggle_sim, md_per_a,
dv_per_a, nm_per_a, md_per_b, dv_per_b, nm_per_b, md_pol_a,
dv_pol_a, nm_pol_a, md_pol_b, dv_pol_b, nm_pol_b, md_env,
dv_env, nm_env, s_cheg_a, s_cheg_b, s_per_a, s_per_b, s_pol_a,
s_pol_b, s_env):
self.media_cheg_a = m_cheg_a
self.media_cheg_b = m_cheg_b
self.n_sim = n_sim
self.toggle_sim = toggle_sim
if s_cheg_a != 0:
rand_generator.randst(s_cheg_a, 0)
if s_cheg_b != 0:
rand_generator.randst(s_cheg_b, 1)
if s_per_a != 0:
rand_generator.randst(s_per_a, 2)
if s_per_b != 0:
rand_generator.randst(s_per_b, 3)
if s_pol_a != 0:
rand_generator.randst(s_pol_a, 4)
if s_pol_b != 0:
rand_generator.randst(s_pol_b, 5)
if s_env != 0:
rand_generator.randst(s_env, 6)
#Relógio de simulação - variável que contém o valor do tempo em cada instante
self.instant = 0 #valor inicial a zero
self.envernizamento = fila.Fila(self, md_env, dv_env, nm_env, None, 6)
self.polimento_b = fila.Fila(self, md_pol_b, dv_pol_b, nm_pol_b,
self.envernizamento, 5)
self.polimento_a = fila.Fila(self, md_pol_a, dv_pol_a, nm_pol_a,
self.envernizamento, 4)
self.perfuracao_b = fila.Fila(self, md_per_b, dv_per_b, nm_per_b,
self.polimento_b, 3)
self.perfuracao_a = fila.Fila(self, md_per_a, dv_per_a, nm_per_a,
self.polimento_a, 2)
#Lista de eventos - onde ficam registados todos os eventos que vão ocorrer na simulação
#Cada simulador só tem uma
self.event_list = lista.Lista(self)
#Agendamento da primeira chegada
#Se não for feito, o simulador não tem eventos para simular
if self.media_cheg_a != 0:
self.insereEvento(
eventos.Chegada(self.instant, self, self.perfuracao_a,
True)) #começa geração de A
if self.media_cheg_b != 0:
self.insereEvento(
eventos.Chegada(self.instant, self, self.perfuracao_b,
False)) #começa geração de B
def setup(self):
# Serviço - pode haver mais do que um num simulador
# Queues for objects of type A.
#Queues for both objects
aleatorio.Random.reset_stream_count()
self.envernizamento_queue = fila.Fila(
self, 2, self.dist_envernizamento, None,
self.numero_maquinas_envernizamento,
100000 + 1000000 * self.repeticao_i)
self.a_polimento_queue = fila.Fila(self, 1, self.dist_polimento_A,
self.envernizamento_queue,
self.numero_maquinas_polimento_A,
200000 + 1000000 * self.repeticao_i)
self.b_polimento_queue = fila.Fila(self, 2, self.dist_polimento_B,
self.envernizamento_queue,
self.numero_maquinas_polimento_B,
300000 + 1000000 * self.repeticao_i)
self.b_perfuracao_queue = fila.Fila(
self, 1, self.dist_perfuracao_B, self.b_polimento_queue,
self.numero_maquinas_perfuracao_B,
400000 + 1000000 * self.repeticao_i)
self.a_perfuracao_queue = fila.Fila(
self, 1, self.dist_perfuracao_A, self.a_polimento_queue,
self.numero_maquinas_perfuracao_A,
500000 + 1000000 * self.repeticao_i)
# Lista de eventos - onde ficam registados todos os eventos que vão ocorrer na simulação
# Cada simulador só tem uma
self.event_list = lista.Lista(self)
# Agendamento da primeira chegada
# Se não for feito, o simulador não tem eventos para simular
r1 = aleatorio.Random(600000 + 1000000 * self.repeticao_i)
r2 = aleatorio.Random(700000 + 1000000 * self.repeticao_i)
self.insereEvento(eventos.Chegada(self.instant, self, 'A', r1))
self.insereEvento(eventos.Chegada(self.instant, self, 'B', r2))
def __init__(self, execution_time, media_cheg_A, media_cheg_B,
media_serv_envernizamento, desvio_padrao_envernizamento, numero_de_maquinas_envernizamento,
media_serv_polimento_B, desvio_padrao_polimento_B, numero_de_maquinas_polimento_B,
media_serv_perfuracao_B, desvio_padrao_perfuracao_B, numero_de_maquinas_perfuracao_B,
media_serv_polimento_A, desvio_padrao_polimento_A, numero_de_maquinas_polimento_A,
media_serv_perfuracao_A, desvio_padrao_perfuracao_A, numero_de_maquinas_perfuracao_A):
# Tempo de execucao
self.execution_time = execution_time
# Seeds
seed_perfuracao_A = 10
seed_polimento_A = 20
seed_perfuracao_B = 30
seed_polimento_B = 40
seed_envernizamento = 50
# Numero de clientes que vao ser atendidos
self.n_clientes = 100
# Relogio de simulacao - variavel que contem o valor do tempo em cada instante
self.instant = 0 # valor inicial a 0
# Servicos
self.client_queue_envernizamento = servico.Servico(self, numero_de_maquinas_envernizamento, media_serv_envernizamento, desvio_padrao_envernizamento, None, seed_envernizamento)
self.client_queue_polimento_B = servico.Servico(self, numero_de_maquinas_polimento_B, media_serv_polimento_B, desvio_padrao_polimento_B, self.client_queue_envernizamento, seed_polimento_B)
self.client_queue_perfuracao_B = servico.Servico(self, numero_de_maquinas_perfuracao_B, media_serv_perfuracao_B, desvio_padrao_perfuracao_B, self.client_queue_polimento_B, seed_perfuracao_B)
self.client_queue_polimento_A = servico.Servico(self, numero_de_maquinas_polimento_A, media_serv_polimento_A, desvio_padrao_polimento_A, self.client_queue_envernizamento, seed_polimento_A)
self.client_queue_perfuracao_A = servico.Servico(self, numero_de_maquinas_perfuracao_A, media_serv_perfuracao_A, desvio_padrao_perfuracao_A, self.client_queue_polimento_A, seed_perfuracao_A)
# Lista de eventos - onde ficam registados todos os eventos que vao ocorrer na simulacao
self.event_list = lista.Lista(self)
# Agendamento da primeira chegada. Se nao for feito, o simulador nao tem eventos para simular
self.insereEvento(eventos.Chegada(self.instant, self, media_cheg_A, self.client_queue_perfuracao_A))
self.insereEvento(eventos.Chegada(self.instant, self, media_cheg_B, self.client_queue_perfuracao_B))
import os
import lista
import Pila_Cola
usuario = lista.Lista()
Cola = Pila_Cola.Cola()
Pila = Pila_Cola.Pila()
newmatriz = []
transpuesta =[]
#LEER ARCHIVO
def leer():
archivo1 = open("entrada.xml", 'r')
linea = archivo1.readline()
cox = None
coy = None
while linea != "":
if linea == "<operacion>\n":
linea = archivo1.readline()
per = linea.strip('\n\t\r')
Cola.add(per)
if cox == None:
if linea == "<matriz>\n":
linea = archivo1.readline()
array = linea.split(">")
x = array[1].split("<")
cox = x[0]
linea = archivo1.readline()
array = linea.split(">")
#Main
import lista
lista1 = lista.Lista()
listaMen = lista.Lista()
listaMay = lista.Lista()
listaIgu = lista.Lista()
lista3 = lista.Lista()
def main():
print("Está vacía:", lista1.isEmpty())
lista1.append(5)
print("Está vacía:", lista1.isEmpty())
lista1.append(12)
lista1.append(8)
lista1.append(9)
lista1.append(12)
lista1.append(15)
lista1.append(18)
lista1.append(19)
print(lista1.tamanio())
lista1.imprimir()
lista1.reemplazar(4, 6)
lista1.imprimir()
"invertirLista(lista1)"
"duplicarLista(lista1)"
"mezclarListas(lista1, lista1)"
from xml.dom.minidom import parse
from flask import Flask, request, Response
app = Flask("EDD_codigo_ejemplo")
import lista, pila
import json
import os
listadoIP = lista.Lista()
@app.route("/")
def hell():
return "Hello!"
def shutdown_server():
func = request.environ.get('werkzeug.server.shutdown')
if func is None:
raise RuntimeError('Not running with the Werkzeug Server')
func()
@app.route('/shutdown')
def shutdown():
shutdown_server()
return 'Server shutting down...'
@app.route("/ipServidor")
def ipServidor():
return listadoIP.ipServidor