def test__eq__n_elements_queues(self):
"""Duas filas com os mesmos elementos são iguais"""
x = randint(100, 500)
fila1 = Fila()
fila2 = Fila()
for i in range(0, x):
element = randint(0, self.MAX_VALUE)
fila1.enqueue(element)
fila2.enqueue(element)
self.assertEqual(fila1, fila2)
self.assertEqual(fila1, fila2)
def test_enqueue_dequeue_1(self):
"""teste de integração pipeline de filas"""
fila1 = Fila()
fila2 = Fila()
fila3 = Fila()
fila4 = Fila()
for i in range(0, self.max):
fila1.enqueue(i)
fila2.enqueue(fila1.dequeue())
fila3.enqueue(fila2.dequeue())
fila4.enqueue(fila3.dequeue())
self.assertEqual(i, fila4.dequeue())
def main():
pizzaria = Fila()
pedido1 = Pedido("Muçarela")
pedido2 = Pedido("Calabraza")
pedido3 = Pedido("Marguerita")
pedido4 = Pedido("Rúcula")
pizzaria.entrar(pedido1)
pizzaria.entrar(pedido2)
pizzaria.entrar(pedido3)
pizzaria.entrar(pedido4)
pedido = pizzaria.sair()
print("Fazendo pizza: {}".format(pedido))
print("Está vazia? {}".format(pizzaria.vazia))
pedido = pizzaria.sair()
print("Fazendo pizza: {}".format(pedido))
print("Está vazia? {}".format(pizzaria.vazia))
pedido = pizzaria.sair()
print("Fazendo pizza: {}".format(pedido))
print("Está vazia? {}".format(pizzaria.vazia))
pedido = pizzaria.sair()
print("Fazendo pizza: {}".format(pedido))
print("Está vazia? {}".format(pizzaria.vazia))
def main():
vagas = Fila()
print('Comandos\n', 'A - adicionar carro\n', 'R - remover carro\n',
'S - mostrar statatus do estacionamento\n',
'E - Encerrar o programa')
print()
comando = input('Insira o comando desejado: ').upper()
while comando != 'E':
if comando == 'A':
placa = input('Informe o numero da placa: ')
vagas.inserirDado(placa)
comando = input('Insira o comando desejado: ').upper()
elif comando == 'R':
placa = input('Informe a placa do carro que quer remover: ')
vagas.remove(placa)
comando = input('Insira o comando desejado: ').upper()
elif comando == 'S':
print(vagas.getFila())
comando = input('Insira o comando desejado: ').upper()
def setUp(self):
"""Esse método é invocado antes de cada Teste. Prepara o ambiente"""
self.MAX_VALUE = 10000
self.fila_vazia = Fila()
self.x = randint(0, maxsize)
self.fila_um = Fila()
self.fila_um.enqueue(self.x)
self.max = randint(100, 500)
self.fila = Fila()
self.fila.enqueue(self.x)
self.fila_limite = Fila(self.max)
self.python_deque = deque()
for i in range(0, self.max):
element = randint(0, self.MAX_VALUE)
self.python_deque.append(element)
self.fila_limite.enqueue(element)
def test_dequeue(self):
"""dequeue diminui o tamanho da fila em 1"""
self.assertEqual(len(self.fila_um), 1)
self.fila_um.dequeue()
self.assertEqual(len(self.fila_um), 0)
self.assertEqual(self.fila_um, Fila())
size = len(self.fila_limite)
self.fila_limite.dequeue()
self.assertEqual(len(self.fila_limite), size - 1)
def test_str_n_elements_queue(self):
"""Uma fila com n elementos imprime todos os elementos"""
"""Nossa implementação insere no começo e retira no final,
mas também é possível inserir no final e retirar no começo"""
fila = Fila()
fila.enqueue(1)
fila.enqueue(2)
fila.enqueue(3)
fila.enqueue(4)
self.assertEqual(str(fila), "[4, 3, 2, 1]")
def main():
filaTeste = Fila()
filaTeste.inserirdados("ifpb")
filaTeste.inserirdados("teste")
filaTeste.inserirdados("valor final")
print(filaTeste.getFila())
filaTeste.removerDado()
print(filaTeste.getFila())
filaTeste.removev("teste")
#remove o teste
print(filaTeste.remove())
#sai o primeiro valor
print(filaTeste.TamanhoFila())
def __init__(self, max_elementos):
self.__pilha = Pilha()
self.__fila = Fila()
self.__max_elementos = max_elementos
from fila import Fila
from random import randint
from time import sleep
import sys
filaImpressao = Fila()
def adicionarFilaImpressao(documento):
print("Adicionando documento a fila de impressao, aguarde...")
filaImpressao.ENQUEUE(documento)
def imprimir():
for i in range(filaImpressao.LENGTH()):
documento = filaImpressao.DEQUEUE()
tempo_impressao = randint(1,10)
print("Imprimindo...\n")
sleep(tempo_impressao)
print("Documento impresso!\n")
print("A impressão levou: %ds"%(tempo_impressao))
def sair():
print("Saindo...")
sys.exit()
def main():
print("-------------- IMPRESSORA--------------\n")
print("TECLE: \n", "1- Adicionar documento na fila de impressão\n", "2- Imprimir\n","3- Sair.\n")
def executar(self, n_rodadas, fregueses_por_rodada, rho, n_transiente):
""" Funcao de execucao do simulador
Args:
n_fregueses: numero de fregueses
n_rodadas: numero de rodadas da simulacao.
rho: taxa
"""
''' Inicializacao '''
lambd = rho/2 # taxa de chegada.
taxa_servico = 1 # taxa de servico.
fila1 = Fila(1) # fila 1, mais prioritaria (chegadas exogenas).
fila2 = Fila(2) # fila 2, menos prioritaria (nao ha chagadas exogenas).
# eventos = [] # lista de eventos.
total_fregueses_servidos = 0 # total de fregueses que passaram pelo sistema.
total_fregueses_criados = 0 # total de fregueses criados pelo sistema
tempo = 0 # tempo atual da simulacao.
rodada_atual = 0 # rodada da fase transiente.
fregues_executando = None # inicializacao nula do fregues executando.
plot = Plot()
intervalo = (n_transiente + (fregueses_por_rodada * n_rodadas)) * 0.1
metricas = Metrica(n_rodadas, fregueses_por_rodada)
if n_transiente > 0:
id_proximo_fregues = - n_transiente
else:
id_proximo_fregues = 0 # id do proximo fregues a ser criado (fase transiente arbitraria)
''' Casos DETERMINISTICOS '''
deterministico = False
xs1 = [0]
xs2 = [0]
if deterministico: # Caso de Interrupcao.
chegadas = [1, 4] # Os vetores representam caracteristicas de todos os fregueses.
xs1 = [1, 2]
xs2 = [5, 2]
# chegadas = [0, 4] # Caso de Servidor Ocioso.
# xs1 = [1, 1]
# xs2 = [1, 2]
''' Execucao da SIMULACAO '''
inicio = datetime.now()
while total_fregueses_servidos < n_rodadas * fregueses_por_rodada: # Loop de execucao sobre as RODADAS.
# Tempo de chegada conforme sistema Deterministico:
if deterministico:
if len(chegadas) > 0:
tempo_ate_prox_chegada = chegadas.pop(0)-tempo
else:
tempo_ate_prox_chegada = 10
# Tempo de chegada conforme sistema Exponencial:
else:
tempo_ate_prox_chegada = Utils.gera_taxa_exp(lambd)
tempo += tempo_ate_prox_chegada
# Loop de execucao enquanto ainda nao chegar um novo fregues
while tempo_ate_prox_chegada > 0 and fregues_executando is not None:
# Se a execucao do fregues acabar antes da proxima chegada.
if fregues_executando.tempo_restante <= tempo_ate_prox_chegada:
tempo_ate_prox_chegada -= fregues_executando.tempo_restante # O tempo ate a prox chegada sera subtraido do tempo de servico do fregues em execucao
fregues_executando.tempo_restante = 0
tempo_atual = tempo - tempo_ate_prox_chegada
cor = fregues_executando.cor
# eventos.append(Evento(tempo_atual, fregues_executando.fregues_id, TipoEvento.FIM_SERVICO, fregues_executando.prioridade))
# Atualizacao de metricas de acordo com a fila do fregues (1 ou 2).
# E realizacao da troca de filas (para o fregues que executou em 1) ou evento de fim de execucao (fregues dafila 2)
if fregues_executando.prioridade == 1:
w1 = tempo_atual - fregues_executando.tempo_chegada1 - fregues_executando.tempo_servico1
if cor <= n_rodadas: # so calcula metricas dos fregueses ate n_rodadas
metricas.acumula_w1(w1, cor)
plot.w1_acumulado += w1
metricas.acumula_t1(w1, cor)
fregues_executando.troca_fila(tempo_atual)
fila2.adiciona(fregues_executando)
# eventos.append(Evento(tempo_atual, fregues_executando.fregues_id, TipoEvento.CHEGADA, 2))
else:
w2 = tempo_atual - fregues_executando.tempo_chegada2 - fregues_executando.tempo_servico2
if cor <= n_rodadas: # so calcula metricas dos fregueses ate n_rodadas
metricas.acumula_w2(w2, cor)
plot.w2_acumulado += w2
metricas.acumula_t2(w2, cor)
# if para garantir que os fregueses das rodadas foram os servidos
if fregues_executando.cor > 0 and fregues_executando.cor <= n_rodadas:
total_fregueses_servidos += 1
# Caso exista freguese na fila: coloca-lo em execucao (Prioridade para fila 1).
if fila1.tamanho() > 0:
fregues_executando = fila1.proximo_fregues()
else:
if fila2.tamanho() > 0:
fregues_executando = fila2.proximo_fregues()
else:
fregues_executando = None
# Caso chegue um outro fregues no meio da execucao do fregues atual.
else:
fregues_executando.tempo_restante -= tempo_ate_prox_chegada
tempo_ate_prox_chegada = 0
# Tratando as rodadas.
if id_proximo_fregues >= 0 and id_proximo_fregues % fregueses_por_rodada == 0:
rodada_atual += 1
if deterministico and total_fregueses_servidos == fregueses_por_rodada:
break
# Chega um novo fregues: entra na fila 1.
fregues = Fregues(id_proximo_fregues, tempo, taxa_servico, rodada_atual, xs1[0], xs2[0])
if deterministico:
del xs1[0]
del xs2[0]
# Atualizacao de Metricas.
if rodada_atual <= n_rodadas:
metricas.acumula_x1(fregues.tempo_servico1, rodada_atual)
metricas.acumula_t1(fregues.tempo_servico1, rodada_atual)
metricas.acumula_nq1(fila1.tamanho(), rodada_atual)
metricas.acumula_n1(fila1.tamanho(), rodada_atual)
metricas.acumula_x2(fregues.tempo_servico2, rodada_atual)
metricas.acumula_t2(fregues.tempo_servico2, rodada_atual)
metricas.acumula_nq2(fila2.tamanho(), rodada_atual)
metricas.acumula_n2(fila2.tamanho(), rodada_atual)
plot.nq1_acumulado += fila1.tamanho()
plot.nq2_acumulado += fila2.tamanho()
# eventos.append(Evento(tempo, id_proximo_fregues, TipoEvento.CHEGADA, 1))
# Rotina de verificacao de quem deve executar.
if fregues_executando is None:
fregues_executando = fregues
else: # Interrupcao, Novo fregues executa.
if fregues_executando.prioridade == 2:
fila2.volta_para_fila(fregues_executando)
fregues_executando = fregues
if rodada_atual <= n_rodadas:
metricas.acumula_ns2(1, rodada_atual)
plot.ns2_acumulado += 1
metricas.acumula_n2(1, rodada_atual)
else: # Novo fregues para fila 1.
fila1.adiciona(fregues)
if rodada_atual <= n_rodadas:
metricas.acumula_ns1(1, rodada_atual)
plot.ns1_acumulado += 1
metricas.acumula_n1(1, rodada_atual)
id_proximo_fregues += 1
total_fregueses_criados += 1
# if id_proximo_fregues % intervalo == 0:
plot.w1.append(plot.w1_acumulado / total_fregueses_criados)
plot.nq1.append(plot.nq1_acumulado / total_fregueses_criados)
plot.ns1.append(plot.ns1_acumulado / total_fregueses_criados)
plot.w2.append(plot.w2_acumulado / total_fregueses_criados)
plot.nq2.append(plot.nq2_acumulado / total_fregueses_criados)
plot.ns2.append(plot.ns2_acumulado / total_fregueses_criados)
# Impressao dos parametros de entrada.
tabela_parametros = PrettyTable(["n_rodadas", "fregueses/rodada", "fase_transiente", "rho", "lambda"])
tabela_parametros.add_row([n_rodadas, fregueses_por_rodada, n_transiente, rho, lambd])
print(tabela_parametros, "\n")
# Calculo e impressao das metricas.
metricas.calcula(deterministico)
fim = datetime.now()
total = fim - inicio
print("Tempo de execucao: " + str(total))
# plota os graficos
plot.desenha(intervalo, n_rodadas, fregueses_por_rodada, n_transiente, rho)
def __init__(self, grafo, vertice):
fila = Fila()
#lista para guardar os vertices por distancia
auxDist = []
for i in range(len(grafo)):
auxDist.append([])
cont = 1
self.__vetor_distancias = ([0] * len(grafo))
self.__vetor_visitacao = ([-1] * len(grafo))
fila.QEUEput(vertice)
fila.QEUEput(-1) # separa a fila por camada
self.__vetor_visitacao[vertice] = cont
cont += 1
distancia = 0
while fila.QEUEempty() != 0:
v = fila.QEUEget()
#se o v for igual a -1 significa que e o fim da fila
if v != -1:
camada = fila.QEUEget()
#aumenta a distancia caso a camada = -1,
aux = distancia
if camada == -1:
distancia += 1
else:
#se a camada nao for igual a -1, ela e inserida novamente no inicio da fila,
# pois se trata de um vertice
fila.addInicioDaFila(camada)
#preenche o vetor de visitaçao
for i in grafo[v]:
if self.__vetor_visitacao[i] == -1:
self.__vetor_visitacao[i] = cont
cont = cont + 1
fila.QEUEput(i)
#verifico se minha distancia mudou
#caso a distancia tenha mudado, insiro meus vertices pertencentes a distancia
if aux != distancia:
auxDist[distancia] = (fila.getFila())
fila.QEUEput(
-1
) # insiro no fim da fila para identificar que e outra camada
#mantem na lista de distancia apenas, as listas nao nulas
auxDist2 = []
for i in auxDist:
if len(i) != 0:
auxDist2.append(i)
#soma a quantidade de cidades por cada distancia
cont = 0
for i in auxDist2:
soma = 0
for j in i:
soma += 1
self.__vetor_distancias[cont] = soma
cont += 1
fila.QEUEfree()
from fila import Fila
from random import randint
from time import sleep
import sys
filaBanco = Fila()
def EntrarNaFila(cliente):
print("Cliente entrando na fila do caixa...")
filaBanco.ENQUEUE(cliente)
def Atender():
for i in range(filaBanco.LENGTH()):
cliente = filaBanco.DEQUEUE()
tempo_Atendimento = randint(1,10)
print("Cliente sendo atendido...\n")
sleep(tempo_Atendimento)
print("Atendimento terminado!\n")
print("O atendimento demorou %d minutos. "%(tempo_Atendimento))
def Sair():
print("Saindo...")
sys.exit()
def main():
print("-------------- BANCO--------------\n")
print("TECLE: \n", "1- Entrar na fila do caixa de atendimento\n", "2- Atendimento\n","3- Sair.\n")
def test__eq__empty_queues(self):
"""Duas filas vazias são iguais"""
self.assertEqual(Fila(), Fila())
#o argumento é a capacidade da fila
self.assertEqual(Fila(5), Fila(10))
from fila import Fila
from tkinter import *
f1 = Fila()
class Application:
#Construtor
def __init__(self, master=None):
self.fonte = ("Verdana", "8")
self.container1 = Frame(master)
self.container1["pady"] = 10
self.container1.pack()
self.container3 = Frame(master)
self.container3["padx"] = 20
self.container3["pady"] = 5
self.container3.pack()
self.container4 = Frame(master)
self.container4["padx"] = 20
self.container4["pady"] = 5
self.container4.pack()
self.container5 = Frame(master)
self.container5["padx"] = 20
self.container5["pady"] = 5
self.container5.pack()
self.container6 = Frame(master)
self.container6["padx"] = 20
self.container6["pady"] = 10
self.container6.pack()
self.container7 = Frame(master)
from fila import Fila
fila1 = Fila()
fila1.inserirDado(0)
fila1.inserirDado(1)
fila1.inserirDado(2)
print(fila1.getFila())
fila1.remover()
print(fila1.getFila())
fila1.removerDado(2)
tam = fila1.tamanhoFila()
if (tam != 0):
print(fila1.getFila())
else:
print("Lista Vazia")
def menu():
print ('Entre com a opcao: \n', \
'1 para inserir na pilha \n', \
'2 para retirar na pilha\n', \
'3 para mostra o proximo valor a ser retirado da pilha \n', \
'4 verificar se esta vazia \n', \
'##################################### \n', \
'5 para inserir na fila \n', \
'6 para retirar na fila\n', \
'7 para mostra o proximo valor a ser retirado da fila \n', \
'8 verificar se esta vazia \n', \
'9 para finalizar o programa \n')
pilha = Pilha()
fila = Fila()
menu()
contro = input(' ? ')
while contro != 9:
if contro == '1':
pilha.push(input('Qual o valor ?'))
elif contro == '2':
pilha.pop()
elif contro == '3':
pilha.peek()
elif contro == '4':
pilha.empty()
elif contro == '5':
fila.push(input('Qual o valor ?'))
elif contro == '6':
def __init__(self):
self.fila = Fila()
self.removidas = []
def setUp(self):
self.fila = Fila([0, 1, 2, 3, 4, 5])
from fila import Fila
fila_sem_max = Fila()
# testando inserir em fila sem maximo de elementos definidos.
print("fila sem maximo de elementos definidos")
fila_sem_max.inserir("Joker")
fila_sem_max.inserir("Bruce Wayne")
fila_sem_max.inserir("James Gordon")
fila_sem_max.inserir("Selina")
print(fila_sem_max)
# testando inserir em fila com maximo de elementos definidos.
fila_com_max = Fila(max_tamanho=5)
fila_com_max.inserir("Comedian")
fila_com_max.inserir("Spectral")
fila_com_max.inserir("Sally Jupiter")
fila_com_max.inserir("Roschach")
fila_com_max.inserir("Night Owl")
print("fila com maximo de elementos definidos")
print(fila_com_max)
try:
fila_com_max.inserir("Manhattan")
except Exception:
print("A fila está cheia")
for i in range(fila_sem_max.tamanho()):
print(fila_sem_max.remover())
from fila import Fila
from pilha import Pilha
from listaencadeada import Lista_Encadeada
#Teste da fila
print('Teste da fila')
f = Fila()
f.inserir(10)
f.inserir(20)
f.inserir(30)
print(f.retornar_lista())
f.remover()
print(f.retornar_lista())
# Teste da pilha
print('Teste da pilha')
p = Pilha()
p.inserir(10)
p.inserir(20)
p.inserir(30)
print(p.retornar_lista())
p.remover()
print(p.retornar_lista())
#Teste da lista encadada
print('Teste da lista encadada')
e = Lista_Encadeada()
e.inserir(0, 10)
e.inserir(0, 20)
e.inserir(1, 30)
print(e.retornar_lista())
def __init__(self):
self.entrada = Fila()
self.mesas = [Mesa(), Mesa(), Mesa(), Mesa()]
self.caixas = [Fila(), Fila()]
self.tempo = 2
