Relatorio Exercício de Programação 1

Sistema de Atendimento com Clientes Impacientes

Documento gerado através do Markdown1 (saída em formato PDF), contendo os scripts, resultados e seu
relatório.
Integrantes do grupo:
Gustavo Kiyoshi Takeda nº 8558424
Jeferson Bonfante nº

Script completo

# Simulacao de Sistema de atendimento com clientes impacientes

rm(list=ls())

#Parâmetros do programa:

#numeroDeGuiches(n): número de guichês existentes

numeroDeGuiches = 5

#taxaDeEntradaDeClientes(lambda): taxa de entrada de clientes

taxaDeEntradaDeClientes = 3

#taxaDeAtendimento(mi): taxa de atendimentos a clientes por cada guichê

taxaDeAtendimento = 0.5

#intervaloMaximo(T): intervalo de tempo total sobre o qual se deseja calcular as

#médias de aceitações e rejeições
intervaloMaximo = 50

#iteracoesTotais(N): número de iterações da simulação.

iteracoesTotais = 0

#iteracoesMaximas: valor máximo de iterações(limitador), caso a condição de parada da

#amplitude do intervalo de 95% de confiança não seja atingido
iteracoesMaximas = 20000

#Função que simula o sistema de atendimento dado os parametros passados

simulaSistemaDeAtendimento = function(numeroDeGuiches, taxaDeEntradaDeClientes, taxaDeAtendimento, inter
#Parametros inicias da simulação:

#chegadaUltimoCliente(Tc): instante da chegada do ultimo cliente até o momento

chegadaUltimoCliente = 0

#guiches: Vetor com numeroDeGuiches(n) posições que representa o

# instante em que cada guichê estará disponivel
#(preenche) o vetor com o valor 0

1
guiches = rep(0,numeroDeGuiches)

#clientesNaFila(k) k: contador de clientes que entraram na fila até o momento

clientesNaFila = 0

#chegadaDoClienteNaFila(ctcheg):
#vetor de tamanho variável em que chegadaDoClienteNaFila[k] > 0 denota o
#instante em que o k-ésimo cliente chegou.
chegadaDoClienteNaFila = rep(0,0)

#clientesAtendidos(x) contador de clientes já atendidos

clientesAtendidos = 0

#clientesNaoAtendidos(y) contador de clientes que foram embora sem entrar na fila

clientesNaoAtendidos = 0

#comprimentoDaFila(r) comprimento atual da fila

comprimentoDaFila = 0

#proporcaoDeDesistentes(w): proporção de clientes que foram embora: w = y/(x + y + r)

proporcaoDeDesistentes = 0

#tempoMaximoDePermanencia(tm): tempo máximo de permanência dentre todos os clientes

#atendidos até o momento.
tempoMaximoDePermanencia = 0

#intervaloDaProximaRequisicao(z): Intervalo de tempo da próxima requisição, usa taxaDeEntradaDeCliente

intervaloDaProximaRequisicao = rexp(1, taxaDeEntradaDeClientes)

#Enquanto o tempo de chegada do ultimo cliente + o tempo da próxima requisição não estoura
# o limite do intervaloMaximo, executa a simulacao
while (chegadaUltimoCliente + intervaloDaProximaRequisicao <= intervaloMaximo){

#Atualiza o tempo de chegada do utlimo cliente

chegadaUltimoCliente = chegadaUltimoCliente + intervaloDaProximaRequisicao

#Incrementa a quantidade de clientes(a ideia é que todo cliente que chega passe pela fila)
# mesmo que exista um guiche livre e ele seja atendido em seguida
clientesNaFila = clientesNaFila + 1

#Armazena na posição do cliente o seu respectivo tempo de chegada (chegadaUltimoCliente)

chegadaDoClienteNaFila = rbind(chegadaDoClienteNaFila, c(chegadaUltimoCliente))

#Enquanto menor tempo disponivel dos guiches for menor ou igual ao tempo de chegada do ultimoe clien
#e o número de clientes atendidos(podem estar em atendimento) for menor que o número de clientes na
#inicia o atendimento de um novo cliente
while((guiches[which.min(guiches)] <= chegadaUltimoCliente) && (clientesAtendidos < clientesNaFila))

#incrementa o número de clientes atendidos

clientesAtendidos = clientesAtendidos + 1

#guicheDisponivel(j): Pega o guiche com menor tempo, que está disponivel para atender o cliente
guicheDisponivel = which.min(guiches)

2
 #gera o tempo de atendimento do guicheDisponivel(j) usando a distribuição exponencial
tempoDeAtendimento = rexp(1, taxaDeAtendimento)

#Atribui ao guiche o tempo em que estará disponivel, pegando o maior valor

# entre o ultimo tempo do guiche e o tempo de chegada do cliente que está sendo atendido
# somando o tempo de atendimento do guiche

guiches[guicheDisponivel] = max(guiches[guicheDisponivel], chegadaDoClienteNaFila[clientesAtendido

#Atualiza o tempo maximo de permanencia dentre todos os clientes

tempoMaximoDePermanencia = max(tempoMaximoDePermanencia, (guiches[guicheDisponivel] - chegadaDoCli
}

#Atualiza comprimentoDaFila(r)
comprimentoDaFila = max(0, (clientesNaFila - 1) - clientesAtendidos)

#calcula a probabilidade do clente ir embora

#Gere o indicador de que o cliente que acabou de chegar irá embora
probabilidadeDeDesistencia = rbinom(1, 1, comprimentoDaFila/(comprimentoDaFila + numeroDeGuiches))

#Se o cliente desistir, diminui a quantidade de clientes na fila, e incrementa a

#quantidade de clientes não atendidos
if(probabilidadeDeDesistencia == 1){
clientesNaFila = clientesNaFila - 1
clientesNaoAtendidos = clientesNaoAtendidos + 1
}

#Atualiza o comrpimento da fila Real

comprimentoDaFila = clientesNaFila - clientesAtendidos

#Atualiza a proporção de clientes desistentes

proporcaoDeDesistentes = clientesNaoAtendidos/(clientesAtendidos + clientesNaoAtendidos + compriment

#Gera o intervalo de requisicao do proximo cliente

intervaloDaProximaRequisicao = rexp(1, taxaDeEntradaDeClientes)
}
return (list(x=clientesAtendidos, y=clientesNaoAtendidos, r=comprimentoDaFila, w=proporcaoDeDesistente
}

#Funcao que ira executar a simulacao de atendimento iteracoesMaximas(N) vezes

#Ou ate cumprir a regra da amplitude do intervalo de 95% de confianca para W for menor que 0.005
executaRepeticoesSimulacao = function(iteracoesMaximas,numeroDeGuiches, taxaDeEntradaDeClientes, taxaDeA
#Cria os vetores que irao armazenar os resultados obtidos nas simulacoes para todas iteracoes
vetorClientesAtendidos = rep(0,0)
vetorClientesNaoAtendidos = rep(0,0)
vetorComprimentoDaFila = rep(0,0)
vetorProporcaoDeDesistente = rep(0,0)
vetorTempoMaximoDePermanencia = rep(0,0)

#Executa as simulacoes ate o total de iteracoesMaximas(N)

for (i in 1:iteracoesMaximas) {
#Atualiza o total de iteracoesTotais com i
iteracoesTotais <<- i

3
 #Executa uma simulacao passando os parametros necessarios
atendimentos = simulaSistemaDeAtendimento(numeroDeGuiches, taxaDeEntradaDeClientes, taxaDeAtendiment

#Recebe os valores da simulacao, aumenta o tamanho dos vetores e atribui os resultados

vetorClientesAtendidos = rbind(vetorClientesAtendidos, c(atendimentos$x))
vetorClientesNaoAtendidos = rbind(vetorClientesNaoAtendidos, c(atendimentos$y))
vetorComprimentoDaFila = rbind(vetorComprimentoDaFila, c(atendimentos$r))
vetorProporcaoDeDesistente = rbind(vetorProporcaoDeDesistente, c(atendimentos$w))
vetorTempoMaximoDePermanencia = rbind(vetorTempoMaximoDePermanencia, c(atendimentos$tm))

#Printa a amplitude a cada 100 iteracoes para testar

if (i%%100==0){
#Calcula a amplitude do intervalo de 95%
erroPadrao = sd(vetorProporcaoDeDesistente)/sqrt(length(vetorProporcaoDeDesistente))
amplitudeDoIntervalo = 2*1.96*erroPadrao
#Printa a amplitude
#print(amplitudeDoIntervalo)
#Se a amplitude do intervalo for menor que 0.02 retorna os resultados
if(amplitudeDoIntervalo < 0.005){
#Retorna os vetores obtidos com as simulacoes ate a condicao
return (list(X=vetorClientesAtendidos, Y=vetorClientesNaoAtendidos, R=vetorComprimentoDaFila, W=
}
}
}
#Retorna os vetores obtidos com as simulacoes ate o numero maximo de iteracoes
return (list(X=vetorClientesAtendidos, Y=vetorClientesNaoAtendidos, R=vetorComprimentoDaFila, W=vetorP
}

#Executa todas as simulacoes

resultadoDasSimulacoes = executaRepeticoesSimulacao(iteracoesMaximas,numeroDeGuiches, taxaDeEntradaDeCli

#Armazena os resultados obtidos em todas as simulacoes

clientesAtendidosSimulacoesTotais = resultadoDasSimulacoes$X
clientesNaoAtendidosSimulacoesTotais = resultadoDasSimulacoes$Y
comprimentoDaFilaSimulacoesTotais = resultadoDasSimulacoes$R
proporcaoDeDesistentesSimulacoesTotais = resultadoDasSimulacoes$W
tempoMaximoDePermanenciaSimulacoesTotais = resultadoDasSimulacoes$TM

#Grafico convergência de proporcaoDeDesistentesSimulacoesTotais(Wk) com valores crescentes de k

#e grafico de convergência de TMk com valores crescentes de k
iters = seq(100, iteracoesTotais, by=100)
qtdIter = length(iters)
mediaProporcaoDeDesistentesSimulacoesTotais = rep(0, qtdIter)
mediaTempoMaximoDePermanenciaSimulacoesTotais = rep(0, qtdIter)

#Pega o valor do desvio padrão da proporcaoDeDesistentesSimulacoesTotais

sd_proporcaoDeDesistentesSimulacoesTotais = sd(proporcaoDeDesistentesSimulacoesTotais)/sqrt(length(propo

#Pega o valor do desvio padrão da tempoMaximoDePermanenciaSimulacoesTotais

sd_tempoMaximoDePermanenciaSimulacoesTotais = sd(tempoMaximoDePermanenciaSimulacoesTotais)/sqrt(length(t

4
for (i in 1:qtdIter) {
Natu = iters[i]
mediaProporcaoDeDesistentesSimulacoesTotais[i] = sum(proporcaoDeDesistentesSimulacoesTotais[1:Natu])/N
mediaTempoMaximoDePermanenciaSimulacoesTotais[i] = sum(tempoMaximoDePermanenciaSimulacoesTotais[1:Natu
}

Subproblema 1:

1.

Um gráfico de linha no qual, para cada k pertence {100, 200, . . . , N}, sejam apresentadas as médias parciais
e seus respectivos intevalos de 95%
0.182
0.180
E(W)

0.178
0.176

0 500 1000 1500 2000 2500 3000

2.

Um gráfico de linha no qual, para cada k pertence {100, 200, . . . , N}, sejam apresentadas as médias parciais
e seus respectivos intevalos de 95% de confiança

5
 17.2
17.0
E(TM)

16.8
16.6

0 500 1000 1500 2000 2500 3000

3.

Os histogramas de W e de tm obtidos nas N iterações;

80
60
Frequency

40
20
0

0.0 0.1 0.2 0.3 0.4

proporcaoDeDesistentesSimulacoesTotais

6
 150
Frequency

100
50
0

10 15 20 25 30 35

tempoMaximoDePermanenciaSimulacoesTotais

4.

Imprimir as médias finais X, Y ,tm,tm nas N iterações

## [1] 120.5656250 27.1737500 1.9943750 0.1779933 16.7575651

5.

Imprimir Pr(tm > 13)

## [1] 0.8

6.

Imprimir o valor de ws para o qual P r d(w > ws) < 5%. Note que esse valor corresponde ao quantil 0.95 dos
valores simulados de w.
## 95%
## 24.29271

Subproblema 2:

## [1] "Número de guiches:"

## [2] "1"
## [3] "Probabilidade de desistentes <= 20%"
## [4] "0"
## [1] "Número de guiches:"
## [2] "2"
## [3] "Probabilidade de desistentes <= 20%"
## [4] "0"

7
## [1] "Número de guiches:"
## [2] "3"
## [3] "Probabilidade de desistentes <= 20%"
## [4] "0"
## [1] "Número de guiches:"
## [2] "4"
## [3] "Probabilidade de desistentes <= 20%"
## [4] "0"
## [1] "Número de guiches:"
## [2] "5"
## [3] "Probabilidade de desistentes <= 20%"
## [4] "0.0125"
## [1] "Número de guiches:"
## [2] "6"
## [3] "Probabilidade de desistentes <= 20%"
## [4] "0.300769230769231"
## [1] "Número de guiches:"
## [2] "7"
## [3] "Probabilidade de desistentes <= 20%"
## [4] "0.831904761904762"
## [1] "Número de guiches:"
## [2] "8"
## [3] "Probabilidade de desistentes <= 20%"
## [4] "0.996"