Este relatório está organizado por tópicos que julgo servirem para para uma introdução rápida ao algoritmo, e foi construído com o intuito de ser fácil de consultar.
Pouco convencional
um relato de insegurança acerca deste relatório
Três fases
fala brevemente sobre as três fases essenciais do simulador
Estrutura e análise de eventos
sobre o amadurecimento da ideia do algoritmo e as implicações que isso tem nas estruturas escolhidas, em particular, na análise de eventos.
Design do código
sobre as minhas tentativas de tornar o código perceptível e eficiente
Dados
informações sobre os dados que a simulação devolve
Tipos de dados
A explicitação dos diferentes tipos de dados utilizados na simulação, incluíndo as suas descrições e respectivo código-fonte
Exemplo de utilização
Exemplo de um resultado para determinados parâmetros.
Implementação
O código-fonte do pacote principal
Conclusão
Talvez o meu uso de eventos não seja o mais convencional, mas possibilita-me uma simulação mais interessante. Talvez não devesse mostrar tantos dados, ou o formato que escolhi para este relatório não seja o mais adequado. Talvez seja tarde demais para estar a trabalhar nele. De qualquer forma, aqui está.
O Simulador é composto por três fases:
- Gerar e inserir eventos na cap, e guardar dados necessários;
- Actualizar dados conforme o estado dos balcões no final da primeira fase;
- Apresentar resultados;
Este funcionamento é simbiótico com outros detalhes de implementação do projeto.
Depois de fazer várias experiências diferentes, pareceu-me que a melhor forma de lidar com alguns dos requisitos deste projeto seria passar os utentes para o próximo evento, e que só precisava de passar mais um dado para categorizar o evento: se se tratara de um evento de entrada (push) ou de saída (pop). Como tal, a minha lógica de anàlise de eventos circula à volta dessa ideia.
Nem toda a gente acha que se deva escrever código da mesma maneira. Porém, algo se tem que decidir, os hábitos de programação ajudam a desenvolver código não só eficiente mas também legível.
Aqui estão alguns exemplos das escolhas que fiz:
Utilizo módulos apenas quando necessário para aumentar a legibilidade do código.
Defino funções onde dá mais jeito, para que tenham acesso a variàveis que modificam colateralmente. Por exemplo, PushEvt, PopEvt e NewEvt, cujos comportamentos são necessários em várias partes do código, precisam de variàveis que só estão definidas dentro da função sim. Por exemplo, NewEvt acede a tec, que é uma das variàveis passadas à função sim, e não quero estar a passar tec como argumento à função porque não é prático e aumenta a complexidade do código de forma desnecessária. Também utiliza PushEvt, por isso está definida depois. PushEvt e PopEvt modificam a cap directamente, para que não seja necessário estar a envocar:
cap = PushEvt[cap, t, utente];Passa a ser mais fácil entender o código quando os conceitos são simples e bem estabelecidos.
Conhecendo o projecto aos poucos
Durante o desenvolvimento do projeto, utilizei nomes aleatórios para facilitar a depuração. Linhas como:
(* Print["DEBUG: ",et,"m ",utente," entra na repartição."]; *)Ajudam-me a identificar problemas com o algoritmo, através do Print de cada uma das ações e do Shift-Enter seguido de Ctrl+F para analisar o percurso de determinado utente durante a simulação.
Acabei por utilizar nomes para outras coisas, que achei que apesar de pouco relevantes, são interessantes. Apesar de saber que têm impacto na performance, achei que removê-los seria muito fácil, e que portanto não teriam grande impacto na minha nota.
É apresentado, para cada balcão, um gráfico que representa as mudanças de número de utentes ao longo do tempo para cada fila de espera (baixa e alta prioridade) que esse balcão possua. Para tal, não utilizei o ListPlot, mas sim PlotBalcao, uma função personalizada baseada na travessia de uma lista de eventos de uma fila, implementada por PlotL:
PlotL[l_, dt_] := Module[{i, nu},
i = 1; nu = 0;
While[i <= Length[l] && l[[i, 1]] <= dt,
If[l[[i, 2]], nu++, nu--];
i++
];
nu
];O resultado assemelha-se ao seguinte:
Para estabelecer os limites superiores e inferiores do Plot, precisei de obter os máximos de utentes em cada fila de cada balcão. Portanto decidi apresentar estes dados para todos os balcões.
Como quase todas as coisas neste projeto, a possibilidade de criar gráficos que variam ao longo do tempo foi criada para depuração, e acabou por ficar.
Por vezes, pode notar-se que o gráfico não exibe uma determinada mudança nos dados (é fácil de notar quando o gráfico desenha linhas inclinadas). Isto acontece porque o Mathemática não percorre todos os pontos do gráfico (são infinitos). Em vez disso, utiliza um intervalo, quanto mais pequeno, mais preciso. Acabei por implementar uma nova função para desenho do gráfico, através de um Plot vazio e Lines, isso fez-me aperceber que poderia reduzir as fazes da aplicação e fazer algumas optimizações. A nova versão é o segundo ficheiro deste gist, lamento que não esteja indentada mas podem sempre copiar para o matemática. Quando tiver tempo melhoro o gist.
Nos primórdios deste projeto, implementei esta funcionalidade apenas para a primeira fila dos balcões 1 e 2.
Mas já que ia mostrar mais dados do que era pedido, decidi também mostrar o nome da pessoa que esperou mais tempo e o número de pessoas máximo em cada fila de cada balcão. Para isso, precisei de guardar em cada utente o momento em que entrou no ultimo balcão,
Os números estimados contabilizam os utentes que não chegaram a sair (2ª fase da simulação).
Já que vou mostrar o máximo, porque não o mínimo também? Foi o que pensei.
Pensando melhor, se calhar o mínimo é um dado irrelevante que vai sempre rondar o valor de tec + tabc.
Seguem-se as descrições de cada tipo de dados usado na simulação.
A Cap é uma lista de eventos ordenada por inst[evt]. Em vez de se ordenar a lista após inserir os eventos, e a favor do facto de, na ultima versão, estes serem gerados completamente sequencialmente, acr[cap, e] insere ordenadamente.
BeginPackage["cap`"];
Needs["eventos`"];
cap::usage = "Tipo das cadeias de acontecimentos pendentes.";
nova::usage = "nova denota a cadeia vazia.";
acr::usage = "acr[c,e] acrescenta o evento e a cadeia c.";
proximo::usage = "proximo[c] retorna o evento na cadeia c de menor instante.";
retira::usage = "retira[c] retira da cadeia em c o evento de menor instante.";
cadeiaVaziaQ::usage = "cadeiaVaziaQ[c] indica se a cadeia em c está vazia.";
Begin["`Private`"];
nova = {};
acr[cap_, e_] := Module[{t, l, idx}, t = inst[e]; l = Length[cap]; idx = 1;
While[idx <= l && t >= inst[cap[[idx]]], idx++];
Insert[cap, e, idx]
];
proximo[cap_] := First[cap];
retira[cap_] := Rest[cap];
cadeiaVaziaQ[cap_] := cap == {};
End[];
EndPackage[];Os eventos são colocados na cap e analisados sequencialmente durante o ciclo principal da simulação.
Como referi na seção "Estrutura de análise de eventos", as suas categorias têm o seguinte formato:
{
isPush ( Boolean ),
utente ( Utente )
}
BeginPackage["eventos`"];
eventos::usage = "A implementacaoo de evento (as suas categorias são costumizaveis).";
evt::usage = "evt[t,c] denota o evento da categoria c que ocorre no instante t.";
inst::usage = "inst[e] retorna o instante em que ocorreu o evento e.";
cat::usage = "cat[e] retorna a categoria (objecto) do evento e.";
Begin["`Private`"];
evt[t_, e_] := {t, e};
inst[e_] := e[[1]];
cat[e_] := e[[2]];
End[];
EndPackage[];Segue-se uma pequena descrição do modo como o tipo de dados Utente é utilizado durante a simulação.
Os utentes moram em dois sítios, nesta simulação:
- Como segundo elemento nas Listas cat[evt]
- Nas filas de espera
Por exemplo, o momento em que um cliente chega à repartição é representado por um evento de categoria push (que é gerado quando um utente acabou de entrar, ou, no caso do primeiro utente, na inicialização). O utente é parte da "categoria" do evento.
Após o evento ser processado, caso lhe tenha sido atríbuido o balcão 2, e o mesmo esteja ocupado, passa a morar na sua respectiva fila de espera de prioridade 1.
Esse comportamento é descrito pelo ciclo principal da simulação, e é a razão para os utentes terem a seguinte estrutura interna:
{
BalcaoInicial, (1 ou 2)
UltimoBalcao (id do ultimo balcao),
Entrou, (t de entrada na repartição)
EntrouBalcao, (t de entrada no ultimo balcão)
Nome (string)
}
E a sua respectiva implementação.
BeginPackage["utentes`"];
utentes::usage = "Implementação do tipo utente.";
NovoUtente::usage = "NovoUtente[x, t] cria um utente aleatoriamente.";
BalcaoInicial::usage = "BalcaoInicial[utente] revela o número do balcão inicial do utente.";
UltimoBalcao::usage = "UltimoBalcao[utente] revela o último balcão no qual o utente foi atendido.";
Entrou::usage = "Entrou[utente] denota t em que o utente entrou na repartição.";
EntrouBalcao::usage = "EntrouBalcao[utente] denota t em que o utente entrou no balcão actual.";
Nome::usage = "Nome[utente] denota o nome do utente.";
AlteraUltimoBalcao::usage = "AlteraUltimoBalcao[utente,n], devolve utente com balcão igual a n.";
ProximoBalcao::usage = "ProximoBalcao[utente], calcula o próximo balcão do utente, com base no actual.";
ProximaPrioridade::usage = "ProximaPrioridade[utente], calcula a proxima prioridade do utente com base no último balcão.";
Begin["`Private`"];
firstNames = { "Noah","Emma","Liam","Olivia","Mason","Sophia","Amy","Jacob","Daniel","David","William","Harry","Ethan","Billy","Mia","Emily","Alexander","James","Abigail","Isabella","Michael","James","Benjamin","Logan","Evelyn","Aiden","Chloe","Jon","Emily","Randy","Peter","Zoey","Lucas","Samuel","Joseph","Anthony","Andrew","Gabriel","Victoria","Grace","Zoey","Natalie","Addison","Lillian","John","Hannah","Luke","Scarlett","Isaac","Oliver","Samantha","Henry","Owen","Claire","Skylar","Levi","Jack","Sarah","Aaron","Ellie","Thomas","Lucy","Alexis","Violet","Bella","Austin","Kevin" };
lastNames = { "Bush","Kirk","Li","Smith","Brown","Roy","Wilson","Leblanc","Williams","Jones","Moore","Johnson","Harris","Parker","Clark","Gonzalez","Barret","Lewis","Robinson","Walker","Young","Sanchez","Scott","King","Baker","Adams","Roberts","Carter","Green","Stewart","Flores","Morris","Murphy","Cook","Peterson","Bell","Reed","Price","Jenkins","Fisher","Perry","Davis","Anderson","White","Jackson","Hall","Lopez","Simmons","Butler","Griffin","Hayes","Ford","Wallace","Woods","West","Freeman","Webb","Black","Knight","Stone","Pierce","Fox","Lawrence","Sims","Chapman","Bishop","Lynch","Garret","Silva" };
RandomName[] := StringJoin[RandomChoice[firstNames], " ", RandomChoice[lastNames]];
NovoUtente[x_,t_] := { If[Random[]<= 1/x, 1,2], 0, t ,0, RandomName[] };
BalcaoInicial[utente_] := utente[[1]];
UltimoBalcao[utente_] := utente[[2]];
Entrou[utente_] := utente[[3]];
EntrouBalcao[utente_] := utente[[4]];
Nome[utente_] := utente[[5]];
AlteraUltimoBalcao[utente_,n_] := { BalcaoInicial[utente],n,Entrou[utente] , EntrouBalcao[utente],Nome[utente]};
ProximoBalcao[utente_] := If[UltimoBalcao[utente]==0||UltimoBalcao[utente]==3,BalcaoInicial[utente], 3];
ProximaPrioridade[utente_] := If[UltimoBalcao[utente]==3,2,1];
End[];
EndPackage[];Os balcões 1 e 2 têm duas filas de espera, a tesouraria apenas uma, mas ambos os comportamentos necessários podem ser descritos da mesma forma:
Quando um cliente sai do balcão, procura-se e atende-se o cliente à frente da fila de maior prioridade que exista.
Como o código de acesso aos balcões é expresso maioritariamente no ciclo principal da simulação, este é um tipo semi-implícito, cujo acesso à fila f é feito da forma b[[2, f]]. A razão para isto é que os acessos aos balcões são diferentes uns dos outros, o que não justifica, na minha opinião, a criação de funções adicionais.
Os balcões são listas com o formato:
{
ocupado (Bool),
Filas (Lista de filas ordenadas em ordem
decrescente por prioridade de atendimento)
}
BeginPackage["balcoes`"];
Needs["filas`"];
balcoes::usage = "Este tipo e semi-implicito no meu projeto, a maior parte da funcionalidade esta em simulaReparticao.m.";
Balcao::usage = "Balcão[n] cria um novo balcao com n filas vazias.";
NPrioridades::usage = "NPrioridades[b] retorna o numero de filas ou prioridades do balcão.";
Begin["`Private`"];
Balcao[n_] := { False,Table[inicial, {i, n}] };
NPrioridades[b_] := Length[b[[2]]];
End[];
EndPackage[];As filas estão implementadas como Listas. Nesta simulação são utilizadas essencialmente para armazenar utentes em espera.
Cada fila corresponde, como já referi, a uma certa prioridade e a um certo balcão.
BeginPackage["fila`"];
fila::usage = "Tipo das filas (generico).";
inicial::usage = "Denota uma nova fila.";
entra::usage = "entra[f, n] acrescenta n ao fim da fila.";
primeiro::usage = "primeiro[f] dá o primeiro elemento da fila.";
sai::usage = "sai[f] devolve uma f sem o primeiro elemento.";
filaVaziaQ::usage = "filaVaziaQ[f] indica se a fila esta vazia.";
Begin["`Private`"];
inicial = {};
entra[f_, n_] := Append[f, n];
primeiro[f_] := First[f];
ultimo[f_] := Last[f];
sai[f_] := Rest[f];
filaVaziaQ[f_] := f == {};
End[];
EndPackage[];uma escolha que pode ser controversa
Por vezes poderá não ser necessário defenir níveis de abstração (funções) para tipos de dados que raramente sejam acedidos da mesma forma, como penso que seja o caso de algumas estruturas de dados deste projeto. No entanto, ao utilizar esta estratégia, corremos o risco de tornar o código menos legível. Esta seção visa, também, preencher essa lacuna o melhor possível.
cData é uma variàvel que nos ajuda a guardar informações que precisamos para apresentar os dados.
É composta por listas correspondentes a cada balcão, compostas por listas correspondentes a cada fila desse balcão.
Os elementos das listas de filas têm o seguinte formato:
{
{
tempo máximo em espera,
nome do utente que aguardou o máximo de tempo
},
lista de: {
t de evento,
push (boolean, tipo de evento)
}
}
O código que gera o cData inicial é o que se segue:
cData = Map[Table[{{0, "Ninguém"}, {}}, {i, NPrioridades[#]}] &, bs];Estas variàveis auxiliares são utilizadas para guardar o mínimo e o máximo de tempo que algum utente ficou na repartição.
Têm o formato:
{
maximo / minimo de tempo,
nome do utente que esperou esse tempo
}
Segue-se um exemplo de utilização da função sim
Chamar a função sim da seguinte forma:
sim[320, 3, 3, 3, 4, 1];Produz-se o resultado:
Simulação t 320 tec 3 x 3 tabc 3 y 4 tt 1
BALCÃO 1:
Utentes em espera:
Fila 1 - maximo de pessoas à espera: 2, Emily Jones foi a pessoa que esperou mais (8.738m)
Fila 2 - maximo de pessoas à espera: 1, Harry Jones foi a pessoa que esperou mais (0.0313994m)
BALCÃO 2:
Utentes em espera:
Fila 1 - maximo de pessoas à espera: 19, Alexis Robinson foi a pessoa que esperou mais (62.9665m)
Fila 2 - maximo de pessoas à espera: 3, Aaron Brown foi a pessoa que esperou mais (13.3551m)
TESOURARIA:
Utentes em espera:
Fila 1 - maximo de pessoas à espera: 3, Emily Jones foi a pessoa que esperou mais (7.62683m)
DADOS GERAIS:
Tempo médio de permanência na repartição (sem contar com os utentes que não saíram): 27.7551m
O cliente que passou mais tempo na repartição foi Natalie Barret (101.133m)
O cliente que passou menos tempo na repartição foi Andrew Lewis (0.0310241m)
Esta seção contêm a implementação do pacote que contem a função sim.
Construí o código de forma que, juntamente com este relatório, fosse perceptível o seu funcionamento. Tentei documentá-lo com comentários nos momentos mais apropriados, e deixei algumas das minhas linhas de debug comentadas, para o leitor poder experimentar fazer a análise do trajeto dos utentes..
Segue-se a parte mais maçuda deste relatório, boa sorte:
BeginPackage["simulaReparticao`"];
Needs["eventos`"];
Needs["cap`"];
Needs["fila`"];
Needs["utente`"];
Needs["balcoes`"];
simulaReparticao::usage = "pacote que disponibiliza a função sim para a simulação de uma repartição de finanças, conforme o enunciado.";
sim::usage = "sim[t,tec,x,tabc,y,tt] efectua a simulacao de utentes em espera numa repartição de finanças durante t minutos, demorando tec minutos entre chegadas de clientes. um em cada x desses clientes vai para o balcao 2, tabc é o tempo médio que demoram a ser atendidos em qualquer balcão, 1 em cada y dos clientes vai à tesouraria após o primeiro balcão, e demoram tt a viajar da tesouraria para os balcões e vice versa.";
Begin["`Private`"];
obsExp[m_] := -m*Log[Random[]];
sim[t_, tec_, x_, tabc_, y_, tt_] := Module[{cap, PushEvt, PopEvt, NewEvt},
cap = nova;
Print[Style["Simulação", Bold], " t ", t, " tec ", tec, " x ", x, " tabc ", tabc, " y ", y, " tt ", tt];
(* insere evento de entrada na cap *)
PushEvt[i_, utente_] := Module[{e},
e = evt[i, {True, utente}];
cap = acr[cap, e];
e
];
(* insere evento de saída na cap *)
PopEvt[i_, utente_] := cap = acr[cap, evt[i, {False, utente}]];
(* insere evento de novo utente na cap *)
NewEvt[et_] := Module[{tick},
tick = et + obsExp[tec];
PushEvt[tick, NovoUtente[x, tick]]
];
Module[{bs, tSum, minU, maxU, nU, cData},
(* inicialização *)
bs = Append[Table[Balcao[2], {i, 2}], Balcao[1]];
nU = tSum = 0;
minU = {Infinity, "Ninguém"};
maxU = {0, "Ninguém"};
cData = Map[Table[{{0, "Ninguém"}, {}}, {i, NPrioridades[#]}] &, bs];
(* geração e iteração da cap *)
Module[{complete, e, et},
e = NewEvt[0];
et = inst[e];
complete = et > t;
cap = acr[nova, e];
(* ciclo principal da simulação *)
While[! complete,
cap = retira[cap];
Module[{ec, isPush, utente},
ec = cat[e];
isPush = ec[[1]];
utente = ec[[2]];
If[isPush,
Module[{nb}, (* evento de ENTRADA *)
(* acabou de chegar *)
If[Entrou[utente] == et,
(* Print["DEBUG: ",et,"m ",utente," entra na repartição."];*)
NewEvt[et]
];
nb = ProximoBalcao[utente];
If[! bs[[nb, 1]], (* LIVRE *)
(* Print["DEBUG: ",et,"m A atender ",utente," em ", nb]; *)
bs[[nb, 1]] = True;
PopEvt[et + obsExp[tabc], AlteraUltimoBalcao[utente, nb]]
,(* OCUPADO *)
(* o utente espera pela sua vez *)
Module[{np},
np = ProximaPrioridade[utente];
(* Print["DEBUG: ",et,"m A pôr ",utente," em espera em ", nb," p:", np]; *)
cData[[nb, np, 2]] =
Append[cData[[nb, np, 2]], {et, True}];
bs[[nb, 2, np]] = entra[bs[[nb, 2, np]], {
BalcaoInicial[utente],
UltimoBalcao[utente],
Entrou[utente] ,
et,
Nome[utente]
}];
];
];
], Module[{b, idx}, (* evento de SAÍDA *)
b = UltimoBalcao[utente];
(* Print["DEBUG: ",et,"m ",utente, " foi atendido(a) em ",b,";"]; *)
If[b == 3, (* se está a sair da tesouraria *)
PushEvt[et + obsExp[tt], utente],
(* senão, e se ainda não lá foi, talvez *)
If[ProximaPrioridade[utente] == 1 && Random[] <= 1/y,
(* vá para a secretaria *)
PushEvt[et + obsExp[tt], utente],
(* ou saia da repartição *)
(* Print["DEBUG: ",et,"m ",utente," sai da repartição."]; *)
Module[{dt},
dt = et - Entrou[utente];
If[dt < minU[[1]], minU = {dt, Nome[utente]}];
If[dt > maxU[[1]], maxU = {dt, Nome[utente]}];
tSum += dt;
nU++;
];
];
];
(* pop de maior prioridade - ver seção "Balcões". *)
idx = Length[bs[[b, 2]]];
While[idx >= 1, Module[{f},
f = bs[[b, 2, idx]];
idx = If[filaVaziaQ[f],
idx - 1,
bs[[b, 1]] = True;
bs[[b, 2, idx]] = sai[f];
Module[{pUtente},
pUtente = primeiro[f];
(* Print["DEBUG: A atender proximo: ", pUtente]; *)
cData[[b, idx, 2]] = Append[cData[[b, idx, 2]], {et, False}];
Module[{dt},
dt = et - EntrouBalcao[pUtente];
If[dt > cData[[b, idx, 1, 1]], cData[[b, idx, 1]] = {dt, Nome[pUtente]}];
];
PopEvt[et + obsExp[tabc], AlteraUltimoBalcao[pUtente, b]];
];
-1
];
]];
If[idx == 0, bs[[b, 1]] = False];
];
];
];
complete = Evaluate[cadeiaVaziaQ[cap] || (
e = proximo[cap];
et = inst[e];
et > t
)];
];
];
(* 2ª fase da simulação *)
Module[{np},
np = 1;
While[np <= Length[bs],
Module[{nf},
nf = 1;
While[nf <= Length[bs[[np, 2]]],
Module[{f},
f = bs[[np, 2, nf]];
If[! filaVaziaQ[f],
Module[{utente, dt, dtt},
utente = primeiro[f];
dt = t - EntrouBalcao[utente];
If[cData[[np, nf, 1, 1]] < dt, cData[[np, nf, 1]] = {dt, Nome[utente]}];
dtt = t - Entrou[utente];
If[maxU < dtt, maxU = {dtt, Nome[utente]}];
If[minU > dtt, minU = {dtt, Nome[utente]}];
]
];
];
nf++;
];
];
np++;
];
];
(* 3ª e última fase: apresentar resultados *)
(* Print[tSum," ", nU," ",minU," ", maxU," ",cData]; *)
(* Print[cData[[1,1,2]]]; *)
PlotL[l_, dt_] := Module[{i, nu},
i = 1; nu = 0;
While[i <= Length[l] && l[[i, 1]] <= dt,
If[l[[i, 2]], nu++, nu--];
i++
];
nu
];
(* Print[PlotL[cData[[1,1,2]],5]]; *)
GetMaxL[l_] := Module[{i, nu, max},
i = 1; max = nu = 0;
While[i <= Length[l],
If[l[[i, 2]], nu++, nu--];
If[nu > max, max = nu];
i++;
];
max
];
(* Print[GetMaxL[cData[[1,1,2]]]]; *)
Module[{labels},
labels = {"BALCÃO 1", "BALCÃO 2", "TESOURARIA"};
PlotBalcao = Function[{bn},
Print[labels[[bn]], ":"];
Module[{b, maxes, fullmax},
b = cData[[bn]];
maxes = Map[GetMaxL[#[[2]]] &, b];
fullmax = Module[{max, i},
max = 0; i = 1;
While[i <= Length[b],
Module[{fmax},
fmax = GetMaxL[b[[i, 2]]];
If[maxes[[i]] > max, max = maxes[[i]]];
];
i++;
];
max
];
Print["Utentes em espera:"];
Print[ (* Plot *)
If[Length[b] > 1,
Plot[
Evaluate[Map[Hold[PlotL[#[[2]], z]] &, b]],
{z, 0, t},
PlotRange -> {0, fullmax},
PlotLegends -> Table[StringJoin["fila", ToString[k]], {k, 1, Length[b]}],
AxesLabel -> {"t", "n"},
Evaluated -> True,
WorkingPrecision -> t
],
Plot[
PlotL[b[[1, 2]], z],
{z, 0, t},
PlotRange -> {0, fullmax},
AxesLabel -> {"t", "n"},
WorkingPrecision -> t
]
]
];
Module[{i},
i = 1;
While[i <= Length[b],
Print["Fila ", i, " - maximo de pessoas à espera: ", maxes[[i]], ", ", b[[i, 1, 2]], " foi a pessoa que esperou mais (", b[[i, 1, 1]], "m)"];
i++
];
];
];
];
Map[PlotBalcao, Table[i, {i, 1, Length[cData]}]];
];
Print["DADOS GERAIS:"];
Print["Tempo médio de permanência na repartição (sem contar com os utentes que não saíram): ", tSum/nU, "m" ];
Print["O cliente que passou mais tempo na repartição foi ", maxU[[2]], " (", maxU[[1]], "m)"];
Print["O cliente que passou menos tempo na repartição foi ", minU[[2]], " (", minU[[1]], "m)"];
];
];
End[];
EndPackage[];Conclusões há muitas, segundo conta a Históra, estão erradas a maioria das vezes. O que retiro deste projeto é, principalmente, mais experiência numa coisa que adoro fazer.
Tenho de admitir que uma implementação "correcta" deste projeto não é fácil, muito menos óbvia, há sempre maneiras melhores de resolver problemas, desde que se empenhe consideração suficiente. Dito isto, espero não ter cometido nenhum erro grave.
Submeto, desta forma, este meu processo de aprendizagem, e agora só me resta esperar pelo melhor.
Obrigado pela leitura.