Modelacao e Simulacao D II

Prévia do material em texto

Versão 30/11/2023
Brauliro G Leal
Modelagem e Simulação Discreta
Sistemas de Fila M/M/1
Quinta Edição
Juazeiro – BA
2023
Modelagem e Simulação Discreta 2
Copyright© 2016, 2017, 2018, 2019, 2020, 2021, 2022, 2023 by Brauliro Gonçalves Leal
O conteúdo deste livro eletrônico é livre para uso de qualquer natureza desde que citado a 
fonte. Toda e qualquer parte desta publicação pode ser reproduzida, distribuída ou 
transmitida de qualquer forma ou por qualquer meio, ou armazenada de qualquer forma ou 
em qualquer sistema desde que reconhecida a autoria.
Atribuição-CompartilhaIgual – esta licença permite que outros remixem, adaptem e 
criem a partir deste trabalho, mesmo para fins comerciais, desde que lhe atribuam o 
devido crédito e que licenciem as novas criações sob termos idênticos 
(creativecommons.org/licenses).
e-mail: ccmp0057@gmail.com
Quinta Edição Eletrônica: setembro 2023
ISBN: a ser feito#
O autor
Brauliro Gonçalves Leal
Professor do Colegiado de Engenharia da Computação
Universidade Federal do Vale do São Francisco
Avenida Antônio Carlos Magalhães, 510 Santo Antônio
Juazeiro/BA – Brasil 48.902-300 
e-mail: brauliro.leal@univasf.edu.br
site: www.univasf.edu.br/~brauliro.leal
Sobre este documento
Este documento foi escrito em LibreOffice (www.libreoffice.org), suas imagens foram 
produzidas pelo Kolourpaint (www.kolourpaint.org), seus programas foram editados na IDE 
Code::Blocks (www.codeblocks.org) e compilados com o GNU GCC (gcc.gnu.org). O Sistema 
Operacional utilizado foi o GNU/Linux Mint Cinnamon.
Software livre é a melhor ideia!
http://www.cecomp.univasf.edu.br/
http://www.codeblocks.org/
http://www.kolourpaint.org/
http://www.libreoffice.org/
http://www.univasf.edu.br/~brauliro.leal
mailto:brauliro.leal@univasf.edu.br
http://portais.univasf.edu.br/
Modelagem e Simulação Discreta 3
Pois o conforto intelectual e o hábito têm horror das mensagens que 
os incomodam.
Edgar Morin (Le Monde: 20 de abril de 2020)
Modelagem e Simulação Discreta 4
Modelagem e Simulação Discreta
Prefácio
O objetivo principal deste livro é servir de texto para a disciplina Modelagem e 
Simulação do curso de Engenharia da Computação do Colegiado de Engenharia da 
Computação da Universidade Federal do Vale do São Francisco.
Os grandes temas deste livro são: Sistemas de Fila, Simulação de Sistemas de Fila, 
Análise de Resultados Simulados, Verificação e Validação de Modelos, Geração de Números 
Aleatórios e Geração de Variáveis Aleatórias.
Neste texto foram construídos os Modelos Analítico, Conceitual e Computacional de 
Sistemas de Fila a partir da Teoria de Filas e dos Modelos de Sistemas de Filas. Estes modelos 
permitem tratar os temas deste livro e são os eixos que dão suporte à teoria e às aplicações 
da Modelagem e Simulação Discreta.
O Modelo Conceitual de Sistemas de Fila e seu respectivo Modelo Computacional, aqui 
apresentados, foram feitos em duas partes. Na primeira parte foi tratado o processo de 
simulação discreta e na segunda a análise estatística dos resultados. Desta forma, são 
enfatizadas as variáveis de real interesse para a simulação, tornando o modelo mais simples 
de ser compreendido. Esta abordagem se revelou assaz didática.
O uso de modelos é amplamente aceito pois permite estudar problemas aos poucos – 
ampliando o escopo quando necessário, maior facilidade para testar um sistema antes de lhe 
dar forma final – reduz custos, melhora a comunicação entre os membros de uma equipe – 
aumento da eficiência das equipes, e contribui com a publicidade dos seus resultados – 
favorece o entendimento do público de interesse.
Os modelos computacionais foram implementados em C++, pelo rigor da linguagem, e 
em Javascript com HTML5, para permitir a visualização gráfica e a dinâmica da simulação 
discreta, viabilizando seu uso em navegadores web. Esta implementação permite a avaliação 
gráfica do comportamento dos sistemas simulados, dando grande estímulo à aprendizagem, 
com resultados inspiradores.
Os algoritmos para a Geração de Variáveis Aleatórias também são contribuições 
relevantes, permitem gerar várias funções de distribuição acumuladas, discretas e contínuas, 
a partir de números aleatórios, dando suporte à simulação computacional.
Outros algoritmos foram desenvolvidos, destinados aos tópicos relevantes da Simulação 
de Sistemas Simples de Fila, para Verificação e Validação de Modelos e também para a 
Análise de Resultados Simulados, com destaque para os métodos de Replicação 
Independente e Média de Lotes.
Modelagem e Simulação Discreta 5
O autor espera que tenha contribuído com o ensino destes conteúdos de modo a torná-
los mais atraentes, visuais, dinâmicos e aplicados nas diversas áreas de conhecimento, 
quando cabível. Na esperança de que os estudantes descubram a expressão racional que se 
descobriu no mundo e que os ajude a reinventá-la.
Os softwares e material didáticos auxiliares foram incluídos no texto e tem como 
finalidade pedagógica, destinam-se a ilustrar os conceitos da disciplina, estão sendo 
melhorados e otimizados e são de uso livre. O autor não assume quaisquer responsabilidades 
pelo seu uso e/ou pelas consequências de seu uso.
Construindo a Modelagem e Simulação de Sistemas Computacionais
A Modelagem e Simulação de Sistemas Computacionais permitem representar Sistemas 
Computacionais por meio de modelos de simulação e reproduzir suas cadeias de causalidade, 
estimar e avaliar resultados e subsidiar o processo de tomada de decisões em nível de 
engenharia. É uma ferramenta que pode ampliar nossa capacidade de análise pois, com seu 
uso, pode-se avaliar inúmeras configurações de Sistemas Computacionais e seus resultados 
e, assim, refinar suas entradas e melhorar suas respostas.
A seguir são relacionados os principais conceitos que dão suporte à modelagem e a 
simulação destes sistemas.
• Matemática – com sua concisão e ubiquidade, a matemática é a linguagem que 
permite escrever o corpo teórico para a modelagem, simulação discreta e análise de 
resultados. As técnicas matemáticas, como Cálculos Diferencial e Integral e Séries, são 
requeridas para qualificar e quantificar as teorias deste livro e seus objetos de estudo
• Teorias da Filas – mais de um século de pesquisa em sistemas de filas permitem 
compreender a organização dos sistemas computacionais e estabelecer suas relações 
físico-matemáticas sob a forma de Modelos Analíticos. Os seus resultados teóricos e 
experimentais atestam o sucesso desta abordagem
• Modelagem Analítica – os modelos de Sistemas Computacionais tornaram possíveis a 
compreensão e a verificação de resultados de simulação discreta, extensíveis aos 
demais recursos de software e de hardware
• Geradores de Variáveis Aleatórias – o acaso é um agente imprevisível e atua em 
todos os domínios da Natureza. Por ser um elemento explicativo nas Ciências, é 
necessário introduzi-lo nos sistemas, o que pode ser feito por meio de números 
aleatórios. Os geradores de números aleatórios são essenciais para gerar variáveis 
aleatórias e suas distribuições estatísticas, viabilizando a simulação computacional a 
partir de poucos valores medidos, mas representativos
• Estatística – a estatística é uma ferramenta usada quando não se sabe, ou é 
impossível saber, totalmente as informações contidas em um sistema. Desta forma, ela 
trabalha melhor com incertezas ao quantificá-las em níveis de confiança. Seus 
conceitos, métodos e técnicas dão o suporte necessário para a validação e verificação 
de experimentos envolvendo sistemas computacionais
Modelagem e Simulação Discreta 6
• Ciência da Computação – computadores, com sua capacidade e velocidades 
extremadas, dão o suporte para a simulação. As linguagens de programação permitem 
escrever os softwares necessários para a simulação e análise de resultados. As técnicas 
computacionais, comoestruturas de dados, programação orientada a objetos, cálculo 
numérico e computação gráfica, dão suporte à simulação. Todo e qualquer hardware ou 
software, os computadores, seus componentes e seus elementos de conexão são, eles 
mesmos, objetos de estudo
• Sistemas Computacionais – os Sistemas Computacionais são transversais na vida 
das pessoas, das empresas e dos governos. Em todas as áreas, sua influência é 
marcante. Sistemas de Computação são recursos de software e/ou de hardware, 
tomados em parte ou no todo, de modo isolado ou em rede e, para sua compreensão e 
seu uso adequado, é necessário um conhecimento básico da terminologia da avaliação 
de desempenho, seus princípios e suas técnicas
Cabe aqui uma ressalva, a de que variáveis aleatórias diferem das variáveis 
deterministas habituais (da ciência e engenharia em geral). Variáveis deterministas 
apresentam um valor único a qual associa-se um erro de medida, como a aceleração da 
gravidade em um ponto deste planeta. Por outro lado, variáveis aleatórias têm seus valores 
associadas a distribuição de probabilidade, que devem ser interpretados tendo em vista 
estatísticas de cada resultado possível, antecipar a face de uma moeda em dado lance ou 
obter certa carta de um baralho.
A simulação discreta faz uso de variáveis aleatórias de modo a representar a grande 
variabilidade dos seus objetos de estudo e seus usos e aplicações nas ciências e na 
sociedade em geral.
Uma outra ressalva é que nossos modelos científicos são apenas modelos, 
simplificações, aproximações que funcionam muito bem e, quando surge algo novo, o modelo 
é aprimorado. Esse é o modo de progresso da Ciência pois ela é inacabada, em eterna 
construção, como nós mesmos e a sociedade, mas busca diminuir as incertezas enquanto 
lida com a complexidade deste universo material.
Visão dos Tópicos Tratados no Livro
A maioria das simulações estocásticas têm a mesma estrutura básica:
1. Identificar uma variável aleatória de interesse X e desenvolver um software para sua 
simulação
2. Gerar as amostras X1, …, Xn independentes e igualmente distribuídas (iid) e com a 
mesma distribuição de probabilidade
3. Estimar estatísticas de X1 e avaliar a precisão da estimativa2
1 Em geral, a média de X.
2 Em geral, intervalo de confiança.
Modelagem e Simulação Discreta 7
A Figura 1 apresenta uma visão dos principais tópicos do livro. O tema central é a 
simulação discreta, ponto de convergência de quatro outros tópicos, discutidos abaixo:
Figura 1 Esquema dos principais destaques do livro.
• Teoria das Filas – ramo da probabilidade que estuda a formação de filas do ponto de 
vista matemático, é utilizada para estabelecer as relações físico-matemáticas dos 
sistemas computacionais e permitem construir seus modelos analíticos, conceituais e 
computacionais
• Geradores de Variáveis Aleatórias (GVA) – permitem gerar valores para funções 
densidade de probabilidade a partir dos geradores de números aleatórios (GNA)
• Validação e Verificação – são técnicas para comprovar se a simulação representa o 
sistema real com fidelidade suficiente para garantir a obtenção de soluções 
satisfatórias para o problema em nível de engenharia
• Simulação de Sistemas de Filas – processo que permite parametrizar, construir e 
reproduzir o comportamento de Sistemas Computacionais por meio de modelos e 
executá-los em computadores
Para a simulação de um Sistema Computacional, o primeiro passo é a construção de um 
modelo, neste caso utiliza-se modelos obtidos a partir da Teoria das Filas. Em seguida, 
obtém-se amostras (medições) representativas de seu comportamento (em geral são 
requeridos poucos dados). Estes dados fornecem os parâmetros que permitem identificar a 
função densidade de probabilidade adequada para a amostra e, assim, gerar inúmeras 
variáveis aleatórias para simulação deste sistema. Os resultados obtidos são valores médios, 
desvios padrões e intervalos de confiança.
A simulação é uma técnica reducionista e sua grande vantagem é que, a partir de um 
modelo de um sistema e uns poucos dados representativos deste sistema, ela permite gerar 
variáveis aleatórias em grande quantidade e que são capazes de reproduzir a dinâmica deste 
sistema, inferindo propriedades do todo com base na amostragem. Atendendo bem as 
Modelagem e Simulação Discreta 8
necessidades dos engenheiros: fazer mais com menos atendendo aos critérios de qualidade 
estabelecidos.
Peço antecipadas desculpas por eventuais erros neste texto, que certamente existem, 
agradeço antecipadamente toda e qualquer correção ou sugestão de melhoramentos, que 
deverão ser enviadas para o e-mail da disciplina: ccmp0057@gmail.com.
Tabela de Símbolos
Nome3 Descrição Unidade
cpf Tempo de chegada de pacote na Fila [s]
CQ Teste χ2
D Estatística do teste χ2
D(X) Desvio Padrão da variável aleatória X
eps Tempo de entrada de pacote no Servidor [s]
F Fila
fda Função distribuição acumulada, F(x)=∫f(x)dx
F Função distribuição acumulada, F(x)=∫f(x)dx
f Função densidade de probabilidade
GCL Gerador Congruente Linear
GNA Gerador de Número (pseudo)Aleatório
GVA Gerador de Variável Aleatória
IC Intervalo de Confiança
ic Intervalo entre chegadas de pacotes na Fila [s/p]
iid Independente e igualmente distribuído
is Intervalo entre saídas de pacotes do Servidor [s/p]
l Taxa de chegada de pacotes na Fila [p/s]
λ Taxa de chegada de pacotes na Fila [p/s]
m taxa de serviço de Servidores de SF [p/s]
M Vetor de taxa de serviço de Servidores de RSF [p/s]
m Esperança matemática de X, média aritmética ou valor esperado
E[X] Esperança matemática de X, média aritmética ou valor esperado
μ Taxa de serviço do Servidor [p/s]
3 O termo pacote será adotado neste texto para indicar as unidades recebidas, processadas e retornadas pelos Sistemas de Fila; são 
sinônimos de pacote os termos tarefa, transação, trabalho, instrução, flops e operação, dentre outras denominações encontradas na 
literatura da área.
Modelagem e Simulação Discreta 9
m Taxa de serviço do Servidor [p/s]
n Número de elementos de uma amostra
N Número de pacotes para simulações dos Sistemas de Fila
ℕ Conjunto dos números naturais
nf Número de pacotes na Fila
ns Número de pacotes no Servidor
nsf Número de pacotes no Sistema de Fila
p Pacote (unidade de trabalho)
p Ordem de chegada dos pacotes
p Parâmetro da distribuição de probabilidade Exponencial
p0 Probabilidade de Servidor Ocioso
r Coeficiente de correlação
r Vetor de rota de pacotes na RSF
RI Método que implementa o método de Repetições Independentes (MRI)
s Desvio padrão da amostra
s Segundo (unidade de tempo) [s]
S Servidor
SF Sistema de Fila
RSF Rede de Sistemas de Fila
sps Tempo de saída de pacote do Servidor (fim do serviço) [s]
T Duração da simulação [s]
tf Tempo de espera de pacote na Fila [s]
ts Tempo de processamento de pacote no Servidor [s]
tsf Tempo de processamento de pacote no Sistema de Fila (tempo de 
resposta)
[s]
U Utilização do Sistema de Fila
U Distribuição Acumulada Uniforme
u Variável aleatória uniformemente distribuída em [0,1]
V Variância
X Amostra X = {X1, X2, …, Xn}
X Variável aleatória
μ Esperança matemática da população
Modelagem e Simulação Discreta 10
ρ Autocorrelação
σ Desvio padrão da população
Modelagem e Simulação Discreta 11
Índice
1 Introdução............................................................................................................................13
1.1 Sistema.............................................................................................................................14
1.2 Modelo..............................................................................................................................15
1.3 Dinâmica Temporal de Sistemas Computacionais.............................................................17
1.4 Simulação.........................................................................................................................181.5 Sistemas de Fila................................................................................................................20
1.6 Simulação de Sistemas de Eventos Discretos...................................................................21
1.7 Simulação de Sistemas Computacionais...........................................................................23
1.8 Etapas de um Estudo de Simulação..................................................................................24
1.9 Revisão.............................................................................................................................27
1.10 Questões 1......................................................................................................................27
1.11 Questões 2......................................................................................................................28
1.12 Exercícios........................................................................................................................29
2 Sistemas de Fila...................................................................................................................30
2.1 Sistemas de Fila M/M/1.....................................................................................................34
2.2 Revisão.............................................................................................................................39
2.3 Questões...........................................................................................................................39
3 Modelo Analítico de Sistemas de Fila...................................................................................40
3.1 Modelo de Sistemas de Fila M/M/1....................................................................................42
3.2 Modelo Analítico de Sistemas de Fila M/M/1.....................................................................42
3.3 Revisão.............................................................................................................................46
3.4 Questões...........................................................................................................................46
3.5 Exercícios..........................................................................................................................47
4 Modelo Conceitual de Sistemas de Fila................................................................................48
4.1 Dados de Entrada para Simulação....................................................................................55
4.2 Valores Iniciais da Simulação............................................................................................60
4.3 Cálculo de cpf...................................................................................................................60
4.4 Cálculo de eps...................................................................................................................61
4.5 Cálculo de sps...................................................................................................................62
4.6 Estatísticas do Modelo Conceitual de Sistemas de Fila.....................................................63
4.7 Algoritmo para Calcular nf.................................................................................................64
4.8 Algoritmo para Calcular U.................................................................................................66
4.9 Sumário do Modelo Conceitual de Sistemas de Filas........................................................67
4.10 Revisão...........................................................................................................................70
4.11 Questões.........................................................................................................................71
4.12 Exercícios........................................................................................................................71
5 Modelo Computacional de Sistemas de Fila.........................................................................73
5.1 Técnica para Gerar ic e ts.................................................................................................75
5.2 Software SF.MM1.cpp........................................................................................................76
5.3 Revisão.............................................................................................................................83
5.4 Questões...........................................................................................................................84
5.5 Exercícios..........................................................................................................................85
6 Verificação e Validação de Modelos.....................................................................................87
6.1 Técnicas de Validação de Modelo......................................................................................88
6.2 Técnicas de Verificação de Modelos..................................................................................89
6.3 Revisão.............................................................................................................................91
6.4 Questões...........................................................................................................................91
6.5 Exercícios..........................................................................................................................92
7 Análise de Resultados Simulados.........................................................................................93
7.1 Remoção de Transientes...................................................................................................94
7.1.1 Estimação por Intervalos de Confiança..........................................................................96
7.1.2 Método das Médias de Lotes..........................................................................................98
7.1.3 Método de Replicação Independente (MRI)..................................................................100
7.2 Critério de Parada...........................................................................................................101
7.2.1 Intervalo de Confiança como Critério de Parada..........................................................102
Modelagem e Simulação Discreta 12
7.2.2 N como Critério de Parada...........................................................................................102
7.3 Que Nível de Confiança Estatística Usar.........................................................................102
7.4 Software SF.MM1-ML-RI.cpp............................................................................................103
7.5 Revisão...........................................................................................................................105
7.6 Questões.........................................................................................................................106
7.7 Exercícios........................................................................................................................106
8 Simulação de Sistemas Computacionais............................................................................109
8.1 Modelo de Rede de Sistemas de Fila (RSF).....................................................................111
8.2 Modelo Conceitual de RSF..............................................................................................111
8.3 Valores Iniciais da Simulação de RSF..............................................................................113
8.4 Roteamento do Primeiro Pacote (p=0)............................................................................114
8.5 Roteamento dos Demais Pacotes (p>0)..........................................................................1158.6 Revisão das RSF..............................................................................................................116
9 Modelo Computacional de Redes de Sistemas de Filas......................................................117
9.1 Sistema Cliente/Servidor Web em uma Camada Física...................................................123
9.2 Sistema Cliente/Servidor Web em duas Camadas Físicas...............................................125
9.3 Sistema Cliente/Servidor Web em três Camadas Físicas................................................126
9.4 Simulação de Sistemas de Hardware..............................................................................129
9.5 Revisão...........................................................................................................................131
9.6 Exercícios........................................................................................................................131
10 Geração de Números Aleatórios......................................................................................132
10.1 Geradores Congruentes Lineares (GCL)........................................................................133
10.2 Aplicação do GCL..........................................................................................................134
10.3 Sementes para o GCL...................................................................................................136
10.4 GCL de uso geral...........................................................................................................136
10.5 Números Aleatórios do GNU C......................................................................................137
10.6 Composição de Geradores............................................................................................139
10.7 Geradores Tausworthe..................................................................................................141
10.8 Outros Geradores..........................................................................................................141
10.9 Classe clGNA.................................................................................................................142
10.10 Teste Empíricos de GNA..............................................................................................143
10.10.1 Testes Empíricos......................................................................................................144
10.11 Testes Teóricos............................................................................................................146
10.11.1 GNA com Distribuição Uniforme...............................................................................147
10.11.2 GNA Estatisticamente Independente.......................................................................148
10.11.3 Custo Computacional de GNA..................................................................................149
10.11.4 Algoritmo para testes teóricos.................................................................................149
10.12 Questões.....................................................................................................................153
10.13 Exercícios....................................................................................................................153
11 Geração de Variáveis Aleatórias......................................................................................155
11.1 Método da Inversa da FDA............................................................................................156
11.2 Método da Convolução.................................................................................................158
11.3 Método da Composição.................................................................................................158
11.4 Método da Aceitação Rejeição......................................................................................158
11.5 Gerar FDA.....................................................................................................................160
11.6 Qualidade na Geração de Variáveis Aleatórias.............................................................162
11.7 Algoritmos para Gerar Variáveis Aleatórias..................................................................162
11.8 Gerar Processos de Chegada.......................................................................................165
11.9 Questões.......................................................................................................................165
11.10 Exercícios....................................................................................................................166
12 Seleção de Distribuições de Probabilidade......................................................................167
12.1 Independência de Observações....................................................................................170
12.2 Distribuições de Probabilidade Úteis.............................................................................171
12.3 Estimação de Parâmetros.............................................................................................172
12.3.1 Método da Máxima Verossimilhança..........................................................................173
12.3.2 Método dos Mínimos Quadrados................................................................................174
12.4 Estimativa dos Parâmetros das FDP..............................................................................174
Modelagem e Simulação Discreta 13
12.4.1 Estimativa dos parâmetros da fdp Exponencial.........................................................174
12.4.2 Estimativa dos parâmetros da fdp Beta.....................................................................175
12.4.3 Estimativa dos parâmetros da fdp Gamma................................................................176
12.4.4 Estimativa dos parâmetros da fdp Weibull.................................................................176
12.5 Identificação da Distribuição Estatística.......................................................................177
12.5.1 Teste Chi-Quadrado (CQ)...........................................................................................178
12.5.2 Testes CQ para fdp Beta.............................................................................................181
12.6 Modelos para Processos de Chegada............................................................................181
12.7 Gerando Processos de Chegada....................................................................................182
12.8 Testando Homogeneidade de Amostras........................................................................182
12.9 Questões.......................................................................................................................184
12.10 Exercícios....................................................................................................................185
13 Recursos do C++ para a Simulação................................................................................188
14 Redução da Variância.......................................................................................................191
14.1 Números Aleatórios Comuns.........................................................................................192
14.2 Variáveis Antitéticas.....................................................................................................192
14.3 Métodos Estatísticos para Comparar Resultados Simulados.........................................196
14.3.1 Teste para Média Zero................................................................................................197
14.3.2 Observações Pareadas...............................................................................................198
14.3.3 Observações não Pareadas........................................................................................19914.4 Questões.......................................................................................................................200
14.5 Exercícios......................................................................................................................200
15 Softwares para Simulação Sistemas de Fila.....................................................................203
15.1 Dicionário de Dados dos Softwares...............................................................................203
15.2 SF.MM1.cpp...................................................................................................................205
15.3 SF.MM1-ML-RI.cpp.........................................................................................................209
15.4 RSF.MM1.cpp.................................................................................................................214
15.5 RSF.MM1-ML-RI.cpp.......................................................................................................219
16 Modelo Analítico de Sistemas de Fila M/M/1....................................................................225
17 GVA pelo Método da Inversa............................................................................................228
17.1 GVA da Distribuição de Probabilidade Exponencial.......................................................228
17.2 GVA da Distribuição de Probabilidade de Valores Extremos.........................................229
17.3 GVA da Distribuição de Probabilidade Logística............................................................229
17.4 GVA da Distribuição de Probabilidade de Pareto...........................................................230
17.5 GVA da Distribuição de Probabilidade Weibull..............................................................231
18 Referências......................................................................................................................232
Modelagem e Simulação Discreta 14
1 INTRODUÇÃO
Os Sistemas Computacionais prestam relevantes serviços e compartilham recursos em 
vários níveis na atualidade, sendo cada vez mais necessários, mais complexos, mais 
abrangentes e mais presentes.
Devido a sua grande importância e alcance espaço-temporal, é necessário a avaliação 
destes sistemas via medição, simulação e modelagem. Dentre estas metodologias, destaca-
se a simulação por ser uma abordagem empírica/matemática que permite, não só o 
entendimento destes sistemas, mas também estimar o melhor uso destes recursos.
Para representar a diversidade dos Sistemas Computacionais são necessários variados 
parâmetros relacionados ao seu desempenho, o conceito de Sistema de Filas, apesar da sua 
simplicidade, é a ideia primária para a compreensão do mais simples ao mais complexo 
Sistema Computacional, da performance de uma CPU à grande rede mundial – a Internet, dos 
sistemas de hardware e dos sistemas de software.
Os Sistemas de Filas são utilizados para a modelagem analítica, simulação e avaliação 
do desempenho de sistemas computacionais, tanto em nível de software quanto de 
hardware. Estes modelos permitem descrever o estado destes sistemas quantificando suas 
variáveis de estado e sua dinâmica temporal.
A Simulação de Sistemas Computacionais pode ser vista como o estudo do 
comportamento de sistemas através de modelos de filas. Ela utiliza outras áreas do 
conhecimento, principalmente estatística, mas também números aleatórios, matemática 
discreta, teoria dos números e técnicas de programação, além de engenharia de software, 
cálculo numérico e computação gráfica.
O uso da Simulação Discreta pode oferecer vantagens quando é necessário estimar 
distribuição de variáveis aleatórias, comparar cenários representando diferentes soluções de 
um problema, avaliar o comportamento de uma solução e avaliar projetos de software e 
hardware.
Modelagem e Simulação Discreta 15
A Simulação Discreta utiliza linguagens de programação para implementar os modelos 
matemáticos de sistemas computacionais e processá-los em computadores, fazendo uso das 
capacidades e velocidades extremadas destas máquinas.
A execução de modelos de Simulação Discreta em computador tem potencial para 
fornecer resultados mais precisos sem a necessidade de interferir nos sistemas reais, 
possibilitando gerar informações úteis na tomada de decisões para a solução de problemas.
A Simulação Discreta é um instrumento com grande potencial de aplicação comercial, na 
pesquisa e em consultoria, principalmente em redes e suas aplicações, um campo em grande 
crescimento. Mas vai além, como banco de dados, sistemas operacionais, sistemas 
embarcados, projetos de hardware e software e gestão de recursos. Bem como na gestão de 
recursos de sistemas multimídia, Computação em Nuvem, Internet das Coisas (IoT), 
Domótica, Cidades Inteligentes, dentre outras áreas emergentes.
A seguir serão apresentados os conceitos de sistema, modelo e simulação, nesta ordem. 
Estes termos estão relacionados, como visto abaixo.
1.1 Sistema
O mundo real é de elevada complexidade e de difícil acesso, a sua compreensão é 
analítica, ou seja, a sua compreensão é feita por partes. Estas partes são chamadas de 
sistemas. A ideia de sistema é aplica em várias áreas do conhecimento. Na engenharia pode-
se entender sistemas como partes do mundo real – algo concreto; pode-se ainda entendê-lo 
como projetos – uma representação físico-matemática que tem realidade no mundo das 
ideias.
O termo sistema pode ser definido como um conjunto estruturado de componentes entre 
os quais pode-se definir alguma relação de funcionalidade seus elementos constituintes. O 
valor dos atributos dos seus componentes, variáveis de estado e parâmetros, em um dado 
instante de tempo, define o estado do sistema, Figura 1.1.
Figura 1.1 Representação gráfica da relação sistema e o mundo real.
Para os propósitos deste livro, os sistemas de interesse são os Sistemas Computacionais, 
que são sistemas orientados a eventos de entrada, processamento e saída, constituídos por 
recursos de software e de hardware, tomados em parte ou no todo, de modo isolado ou em 
Modelagem e Simulação Discreta 16
conjunto. Nosso estudo é focado em Sistemas de Fila para representar Sistemas 
Computacionais, pois são capazes de reproduzir estas estruturas e seu comportamento.
Exemplo 1.1 Exemplo de Sistema
O circuito TTL 7400 da figura ao lado é um exemplo de um sistema, um 
dispositivo que contém quatro portas NAND, cada uma delas com duas 
entradas e uma saída. As portas são independentes; suas variáveis de 
estado são os valores das entradas e saída e seus parâmetros são os 
dados do fabricante.
Os Sistemas de Fila são sistemas gerais e orientados, conforme apresentado abaixo.
Exemplo 1.2 Sistema Orientado
O primeiro passo na aplicação do conceito de sistema a um problema específico é definir o 
que constitui o sistema. Um segundo ponto a ser considerado, é a escolha do nível de 
descrição desejado.
O conceito de sistema geral pode ser considerado como o menor nível de descrição de um 
sistema em que somente as possíveis interações com o mundo exterior são retidas, ficando 
definida sua constituição e aquilo que lhe é externo. Um sistema geral é definido por um 
conjunto de relações entre as entidades que caracterizam as interações com o mundo 
exterior.
Sistema geral é uma relação entre as variáveis que ligam um sistema ao mundo exterior. 
Se forem definidas as variáveis usadas como excitação (entrada) e as variáveis usadas 
como resposta (saída), tem-se um sistema orientado. Um sistema orientado, pode ser 
caracterizado por uma relação entre o conjunto de entradas e saídas.
Os conceitos de sistemas geral e orientado não incluem o tempo como intrínseco ao 
sistema, e as entradas e saídas são tratadas como eventos.
1.2 ModeloModelos são descrições de um sistema, concebidos através de uma abstração da 
realidade considerando seus aspectos relevantes, para permitir uma análise simplificada sem 
descartar seus aspectos importantes.
A construção de um modelo, em geral, busca viabilizar a solução de um problema de um 
sistema, podendo existir um número variado de modelos para um mesmo sistema, cada um 
deles considerando aspectos específicos do mesmo.
A utilidade de um modelo está diretamente relacionada à sua capacidade de incorporar 
elementos reais de forma simples, contendo seus aspectos importantes sem que a sua 
complexidade impossibilite a compreensão e manipulação do mesmo, Figura 1.2.
Modelagem e Simulação Discreta 17
Figura 1.2 Representação gráfica da relação mundo real, sistema e modelo.
Para os propósitos deste livro, os modelos de interesse são os modelos de Sistemas de 
Fila, que são modelos matemáticos capazes de representar os processos de Sistemas 
Computacionais de modo geral, simular seu comportamento, descrever seus aspectos 
relevantes, permitir sua análise e fazer predição de seu comportamento.
O Modelo de Sistemas de Fila tem uso prático (valor de uso), tem predicabilidade (valor 
preditivo), representa os sistemas computacionais (valor de face) e permite construir 
modelos computacionais (valor de simulação), enfim, é útil para os fins propostos.
Exemplo 1.3 Exemplo de Modelo
A figura ao lado é um modelo do circuito TTL 7400, com suas quatro 
portas NAND, cada uma delas com duas entradas e uma saída.. Pode-
se verificar que os elementos desnecessários para caracterização do 
sistema desta figura foram propositalmente abstraídos, restando tão 
somente aqueles que são relevantes e úteis para os propósitos da 
eletrônica digital. Note que foram adicionados símbolos pictóricos ao 
modelo, que são necessários à sua manipulação.
Proponha uma solução matemática dos desafios abaixo.
Desafios
1. Na música Minha História, de Chico Buarque, tem o verso: “Com seu único velho 
vestido cada dia mais curto”. Considerando este verso, identifique e relação 
causa/efeito e faça um modelo matemático para quantificar esta relação.
2. Encontre o modelo matemático implícito no texto bíblico: “a quem tem, mais será 
dado, mas a quem não tem, até o que tiver lhe será tirado”.
O exemplo a seguir mostra o poder dos modelos.
Exemplo 1.4 Os 6 números que definem todo o Universo
O professor de física Lyman Page explica como nosso modelo de Universo é baseado 
apenas em seis parâmetros. Todas as evidências e teorias baseadas em observações do 
universo podem ser reunidas em um modelo padrão de cosmologia que tem apenas seis 
parâmetros.
Como estudamos o Universo como um todo?
Modelagem e Simulação Discreta 18
Meu trabalho se concentra na radiação cósmica de fundo em micro-ondas (CMB, na sigla 
em inglês) — os tênues resquícios de energia do Big Bang — e como medi-la pode guiar 
nosso caminho para a compreensão do Universo. Mas há muitas outras maneiras de 
estudar o cosmos, e os físicos que o fazem se especializam em tudo, desde a relatividade 
geral até a termodinâmica e a teoria das partículas elementares. Fazemos observações em 
quase todos os regimes de comprimento de ondas acessíveis para medição e com 
detectores de partículas de última geração.
As observações provêm de lugares próximos e dos confins mais distantes do espaço.
Todas essas evidências e teorias podem ser reunidas em um modelo padrão 
surpreendentemente simples de cosmologia, que tem apenas seis parâmetros.
O primeiro parâmetro descreve a quantidade de matéria normal, átomos, no Universo, e diz 
que eles representam apenas 5% do Universo.
O segundo parâmetro descreve a matéria escura, um tipo de partícula elementar nova que 
ainda não entendemos, que representa 25% do Universo.
O terceiro parâmetro é a constante cosmológica, a misteriosa energia escura que está na 
raiz da expansão acelerada do Universo.
O quarto parâmetro é a profundidade óptica, ou quão opaco o Universo era para os fótons 
que viajam por ele.
O quinto e o sexto parâmetros descrevem as origens das diminutas flutuações que deram 
origem a toda a estrutura que observamos hoje no Universo.
Em suma, não importa como olhamos para o cosmos — por meio de sondagens de 
galáxias, de estrelas em explosão, da abundância de elementos de luz, das velocidades das 
galáxias ou da CMB —, nós só precisamos de todos os seis parâmetros explicados acima, e 
processos físicos conhecidos, para descrever o Universo que observamos.
O que significa ser capaz de descrever algo de forma tão simples e quantitativa?
Significa que entendemos como as peças do Universo se encaixam para formar o todo. 
Entendemos algumas conexões profundas na natureza. Há poucos sistemas estudados por 
cientistas que podem ser descritos de forma tão simples, completa e com tanta precisão. 
Temos sorte de o Universo observável ser um deles.
Extraído em 07/03/2021 de: https://www.bbc.com/portuguese/geral-55936974
1.3 Dinâmica Temporal de Sistemas Computacionais
O circuito do Exemplo 1.3 será usado para representar da dinâmica temporal de um 
Sistema Computacional, suas variáveis de estado (valor das entradas e saída) e parâmetros 
(dados do fabricante). Neste caso, sinais entram nas portas lógicas, são processados e 
enviados para as saídas.
Modelagem e Simulação Discreta 19
Uma característica importante dos sinais, é que não se sabe quando chegarão. Suas 
chegadas ocorrem ao acaso, é uma variável aleatória.
Uma vez que o sinal chegou, ele é processado. Cada porta lógica tem uma taxa de 
processamento, um dos seus parâmetros de fábrica. A combinação dos valores de entrada, 
em número de quatro, e as variações no sincronismo das duas chegadas podem gerar 
diferentes demandas de processamento e, como não se sabe que valores de entrada 
chegarão e como estão sincronizados, a taxa de processamento também é aleatória.
Generalizando estas ideias, os Sistemas Computacionais recebem tarefas para serem 
processadas. Eles são caracterizados por duas quantidades, a taxa de chegada e a taxa de 
processamento. Estas taxas temporais dão origem ao tempo entre as chegadas e ao tempo 
de processamento. Estes tempos, em geral, são variáveis aleatórias, o tempo entre chegadas 
depende do acaso, e o tempo de processamento depende do tamanho da tarefa que chega, 
que são aleatórios.
Exemplo 1.5 Outras medidas, derivadas do tempo entre as chegadas e do tempo de 
processamento, permitem a tomada de decisão em nível de engenharia, quais sejam:
• Vazão ou Throughput: é o número de tarefas executados em um determinado 
intervalo de tempo. Quanto maior a vazão, maior o número de tarefas executadas em 
função do tempo. A maximização da vazão é desejada na maioria dos sistemas.
• Tempo de Processamento: é o tempo que uma tarefa leva para ser processada. 
Este parâmetro depende do sistema em uso e da tarefa.
• Tempo de Espera: é todo o tempo que a tarefa permanece aguardando para ser 
processada. A redução deste tempo de espera é desejada de modo geral.
• Tempo de Resposta: é o tempo decorrido entre uma requisição ao sistema e o 
instante em que a resposta começa a ser informada.
Estas medidas ou métricas, dentre outras, são objeto de estuda da Simulação de Sistemas 
Discretos.
1.4 Simulação
A simulação permite reproduzir o comportamento dos sistemas, utilizando modelos de 
sistema reais que são representações do sistema e suas conexões com o mundo real, no qual 
está inserido e interage, como mostrado na Figura 1.3. Por meio dela, pode-se manipular um 
modelo de um sistema, real ou hipotético, para compreender seu comportamento ou avaliar 
sua operação, descrever seus aspectos relevantes, permitir sua análise e fazer predição.
Modelagem e Simulação Discreta 20
Figura 1.3 Representação gráfica da relação mundo real, sistema, modelo e simulação.
Uma das grandes utilidades da simulação é tornarpossível fazer estimativas do 
comportamento de um sistema, além de estabelecer como mudanças no sistema podem 
afetar seu comportamento e desempenho, ou seja, a análise de sensibilidade de modelos.
Suas aplicações são amplas e podem focar tantos nas Ciências quanto nas Engenharias. 
Nela podem ser enfatizados aspectos tecnológicos como projetos, protótipos e inovação; e 
bem como os científicos e econômicos. Incluiria também alguns os aspectos sociais.
A simulação pode ser classificada de várias maneiras, a mais comum usa quatro 
categorias: a) simulação contínua; b) simulação Monte Carlo; c) simulação de eventos 
discretos e d) simulação baseada em trace.
Um processo pode ser de estado discreto ou contínuo. Se os valores que suas variáveis 
de estado podem assumir é finito e enumerável, o processo é chamado de processo de 
estado discreto. Por exemplo, o número de pacotes em um sistema de fila pode ter valores 
discretos iguais a 1, 2, 3 e assim por diante, portanto, a formação de filas é um processo de 
estado discreto.
Por outro lado, se as variáveis de estado podem assumir qualquer valor real ele é um 
processo de estado contínuo. O tempo de espera numa fila, teoricamente, pode assumir 
qualquer valor real é, portanto, um processo de estado contínuo. Já o processo de chegada 
na fila é discreto, não ocorre continuamente, ocorre em momentos sucessivos do tempo.
A simulação contínua é utilizada para modelar sistemas cujo estado varia continuamente 
no tempo, sendo comum a utilização de equações diferenciais. A simulação discreta usa 
modelos sistemas cujo estado varia de modo discreto no tempo, utiliza o conceito de 
eventos.
O Método de Monte Carlo é um método estatístico que utiliza amostragens aleatórias 
massivas para obter resultados numéricos, repetindo sucessivas simulações para calcular 
probabilidades. Tem sido utilizado como forma de obter aproximações numéricas de funções 
complexas, utilizando alguma distribuição de probabilidade e uma amostra para aproximar a 
função de interesse. Simulação de Monte Carlo é um modelo de simulação estática, a 
passagem do tempo é irrelevante.
Trace ou Rastreio é um registro cronológico de eventos ocorridos em um sistema real, 
como um log (lista ordenada de eventos de tempo e suas variáveis associadas) de um 
sistema operacional ou o registro de atividades de um monitoramento. A simulação baseada 
em trace utiliza este registro como dados de entrada e, assim, permite avaliar o 
Modelagem e Simulação Discreta 21
comportamento do sistema e seus modelos. Eles podem ser apresentados em vários níveis 
de detalhe: eventos de rastreamento, procedimento trace ou rastreio de variáveis.
Traces são úteis para conhecer o comportamento de sistemas computacionais, são 
fontes de dados para obtenção de funções de distribuição de probabilidade de dados para 
uso em simulação. Como são valores medidos, podem também ser usados na validação e 
verificação de resultados de simulações. Para serem úteis e ter valor estatístico, traces 
devem ser amostras representativas do comportamento do sistema.
Os sistemas discretos são constituídos por sequência de eventos discretos no tempo. 
Cada evento ocorre em um determinado instante de tempo e marca uma mudança de estado 
no sistema. Entre eventos consecutivos, o sistema não muda4 e a simulação pode ser feita de 
evento em evento, sequencialmente, do início ao fim.
A Teoria da Filas é o modelo matemático usado para representar Sistemas 
Computacionais, ela é um ramo da probabilidade que estuda a formação de filas. Este 
modelo matemático demonstra o comportamento de um sistema de oferta de serviços com 
demanda aleatória, envolvendo clientes e provedores de serviços.
A simulação de eventos discretos consiste em processar eventos consecutivos que 
ocorrem em Sistemas de Filas, evento a evento, sequencialmente no tempo, do início ao fim; 
e produzir resultados operacionais de qualidade por meio de estatísticas das suas 
propriedades mensuráveis.
1.5 Sistemas de Fila
Os Sistemas de Fila são modelos matemáticos da Teoria da Filas usados para representar 
Sistemas Computacionais.
Os Sistemas de Fila são descritos por seis parâmetros, utilizando a notação de Kendall 
(A/S/m/K/N/Q em que A – distribuição dos tempos entre as chegadas, S – distribuição dos 
tempos de serviço, m – número de servidores, K – capacidade do sistema, N – tamanho da 
população, e Q – disciplina de atendimento).
Os Sistemas de Fila podem possuir diferentes estruturas e configurações e, por 
simplicidade, mas sem perder o rigor conceitual, será considerado os Sistemas de Fila mais 
simples – aqueles constituídos por uma Fila e um Servidor. De modo geral o termo Pacote5 
denomina as unidades de trabalho dos Sistemas de Fila. Este modelo básico atende às 
necessidades acadêmicas e é capaz de explicar o comportamento de um sistema de oferta 
de serviços com demanda aleatória, envolvendo pacotes em uma fila e um provedor de 
serviços.
4 As mudanças que ocorrerem não afeta o comportamento do modelo do sistema e nem seus resultados.
5 O termo pacote é adotado neste texto para indicar as unidades operacionais dos Sistemas de Fila; são sinônimos de pacote termos: tarefa, 
transação, requisição e instrução. Outras denominações para pacote são encontradas na literatura técnico-científica.
Modelagem e Simulação Discreta 22
Um Sistema de Fila (SF) simples é constituído por: 
a) uma única Fila (F)
b) um único Servidor (S)
c) juntos, a Fila e o Servidor, definem o Sistema de Fila (SF)
d) a demanda é caracterizada pela chegada de clientes na Fila, a taxa de chegada 
e) a oferta é caracterizada pela capacidade de processamento do Servidor, a taxa de 
serviço
f) seus eventos são: chegada de pacotes na Fila, entrada de pacotes no Servidor e 
saída de pacotes do Servidor
A dinâmica do SF, que determina seu comportamento, é feita por simulação dos seus 
eventos, que são discretos no tempo.
1.6 Simulação de Sistemas de Eventos Discretos
Os modelos de Simulação de Eventos Discretos (SED) mais simples possuem uma única 
Fila e um único Servidor. Cada pacote possui três atributos: tempo de chegada no sistema, 
tempo de entrada no servidor e tempo de saída do servidor. O estado do sistema é definido 
pelo seu fluxo de pacotes; e o estado dos pacotes é definido pelos seus atributos.
O objetivo de um modelo de simulação de eventos discretos é representar o fluxo de 
pacotes através de um sistema, atribuir valores aos eventos dos pacotes e, assim 
estabelecer o comportamento e o desempenho deste sistema.
O fluxo de pacotes nos SEDs é caracterizado pela chegada, processamento e partida de 
pacotes. O fluxo de cada pacote através do SED é caracterizado por:
1. chegar no sistema
2. entrar na Fila
3. aguardar na Fila, se necessário
4. entrar no Servidor
5. ser processado no Servidor
6. sair do Servidor
O estado do SED muda em três situações, que podem ocorrer de forma isoladas ou 
conjuntas. A primeira situação é quando o pacote chega na Fila. A segunda é quando o 
pacote entra no Servidor. A terceira situação é quando o pacote sai do Servidor.
Modelagem e Simulação Discreta 23
As mudanças de estado dos SED são imprevisíveis pois ocorrem ao acaso. São três 
eventos discretos aleatórios no tempo cronológico, a saber:
1. chegada do pacote na fila – o pacote entra no sistema de fila
2. entrada do pacote no servidor – o pacote sai da fila e entra no servidor
3. saída do pacote do servidor – o pacote sai do sistema de fila
A Figura 1.4 ilustra o fluxo de pacotes, eventos e tempos dos eventos em Sistema e 
Eventos Discretos. Vale ressaltar que o fluxo de pacotes é a variável independente e que o 
tempo é variável dependente.
Figura 1.4 Fluxo de pacotes, eventos e tempos dos eventos em Sistema e EventosDiscretos; 
o eixo do tempo na vertical indica que ele é variável dependente.
Variáveis de estado derivadas dos eventos discretos:
1. número de Pacotes na Fila
2. condição do Servidor (ocioso/ocupado)
3. tempo de ocupação do Servidor
4. condição de Pacote (na Fila/no Servidor)
5. tempo de espera de Pacotes na Fila
6. tempo de processamento de Pacotes no Servidor
7. duração da simulação
Modelagem e Simulação Discreta 24
Exemplo 1.6 Modelagem e Simulação
Sistemas Computacionais são constituídos por dispositivos de hardware e software. O 
hardware corresponde às partes eletrônicas e mecânicas que possibilitam a existência do 
software e a interação com o usuário. O software fornece as interfaces para que usuários 
executem suas tarefas. Estes sistemas realizam atividades humanas, ou de outros sistemas 
computacionais, por meio do processamento de tarefas. Os Sistemas Computacionais são 
caracterizados, grosso modo, pelos elementos: hardware, software, usuários e tarefas.
A importância dos Sistemas Computacionais reside no seu conjunto de capacidades e 
comportamentos, as quais caracterizam seu desempenho em nível operacional. A 
simulação destes sistemas no âmbito das engenharias pode ser realizada tanto por 
medição quanto por meio da modelagem matemática. A partir de um modelo matemático 
aceitavelmente e representativo de um sistema, pode-se aplicar técnicas matemáticas para 
descrever o seu comportamento e também estimar sua performance comparada a 
indicadores previamente estabelecidos.
A relevância da Modelagem e Simulação reside na sua abrangência cada vez maior. A 
interação entre pessoas, empresas e governos, mediada pela tecnologia tanto em nível 
local quanto global, é um novo estímulo para mudanças sociais e econômicas, promovendo 
cada vez mais a produção de riqueza; além de ser o suporte para a criação de 
conhecimento com a aplicação da Inteligência Artificial, Ciência dos Dados e Internet das 
Coisas, dentre outras áreas aplicadas.
1.7 Simulação de Sistemas Computacionais
A Simulação de Sistemas Computacionais faz uso da Simulação de Eventos Discretos, o 
modelo usado é o Sistema de Filas, que é constituído de Filas e Servidores. Neste sistema, os 
Pacotes entram em uma Fila e são atendidos por um Servidor. Os processos de chegar na 
Fila, entrar no Servidor e sair do Servidor são eventos discretos visto que ocorrem em pontos 
bem definidos do tempo, Figura 1.5. No eixo X desta figura é mostrada uma sequência de 
três pacotes e seus respectivos eventos discretos no eixo Y: chegar na Fila, entrar no Servidor 
e sair do Servidor.
Modelagem e Simulação Discreta 25
Figura 1.5 Sequência de três Pacotes e seus respectivos eventos discretos: chegar na Fila (∎), 
entrar no Servidor (∎) e sair do Servidor (∎).
Pode-se ver que, na Figura 1.5, o eixo X, da variável independente, refere-se a Pacotes 
que chegam ao sistema sucessivamente. Já o eixo Y, da variável dependente, é o tempo e os 
respectivos eventos discretos de cada Pacote: tempo de chegada na Fila, tempo de entrada 
no Servidor e tempo de saída do Servidor.
Um evento discreto acontece em um momento do tempo. Neste caso, o tempo deixa de 
ser a variável independente. Como o estado de um Pacote no Sistema (na Fila ou no Servidor) 
permanece constante entre os eventos, uma descrição completa do estado do Sistema pode 
ser obtido inserindo e processando Pacotes sucessivamente no sistema.
A Simulação de Sistemas Computacionais consiste em representar os estados de um 
Sistemas de Filas, fazer passar por eles uma sequência de Pacotes, quantificar os tempos de 
ocorrência dos eventos discretos de cada Pacote (chegar na Fila, entrar no Servidor e sair do 
Servidor).
O resultado final da Simulação de Sistemas Computacionais é uma tabela de temos dos 
eventos que é usada para produzir resultados operacionais de qualidade por meio de 
estatísticas.
1.8 Etapas de um Estudo de Simulação
O processo de construção de modelos para representar sistemas pode ser organizado 
em uma sequência de estágios, discutidos no Quadro 1.1, segundo Jain (1991).
Modelagem e Simulação Discreta 26
Quadro 1.1 Estágios da construção de modelos para simulação de sistemas
1. Identificação do Problema - problema é discutido no escopo do sistema real ou seu projeto. 
Uma vez identificado o problema, pode-se avaliar a viabilidade do uso da simulação para sua 
solução. Esta avaliação acontece em consonância com os objetivos da simulação e dos seus 
usuários finais
2. Formulação do Problema - após identificado, o problema é então formulado com vistas à 
simulação. Devido à natureza evolucionária da modelagem e da simulação, a definição do 
problema é um processo contínuo, que ocorre em todos estes estágios
3. Objetivos - consiste em identificar claramente os resultados a serem alcançados com a 
simulação, definir critérios para avaliação destes resultados e apresentar suas aplicações, 
restrições e limites das soluções encontradas para o problema. Em seguida são definidos os 
objetivos específicos, para enumerar as características internas do sistema que precisam ser 
representadas no modelo
4. Construção do Modelo Conceitual - o modelo conceitual consiste de uma descrição 
estática e de uma descrição dinâmica. A descrição estática define os elementos do sistema e 
suas características. A descrição dinâmica define o modo como estes elementos interagem 
causando mudanças no seu estado no decorrer do tempo dos eventos. O modelador deve 
conhecer bem a estrutura e as regras de operação do sistema e saber extrair o essencial do 
mesmo, sem incluir detalhes desnecessários. A quantidade de detalhes incluída no modelo 
deve ser baseada no propósito para o qual é construído
5. Determinação dos Dados de Entrada e Saída - geralmente os valores de entrada são, de 
início, hipotéticos ou baseados em alguma análise preliminar. Dependendo do objetivo do 
modelo, amostras representativas do problema são requeridas e são úteis nos estágios 
posteriores do estudo da simulação. Dados da literatura, como dados do fabricante 
(datasheets) e artigos técnicos e científicos, são fontes de dados usuais
6. Construção do Modelo Computacional - é a tradução do modelo conceitual para uma 
forma reconhecida pelo computador
7. Verificação - consiste em determinar se o modelo conceitual é executado pelo computador 
como esperado
8. Validação - busca comprovar que o modelo conceitual representa o sistema real com 
fidelidade suficiente para garantir a obtenção de soluções satisfatórias para o problema. 
Normalmente são utilizados cenários em que o comportamento real já é conhecido 
previamente e que pode ser comparado com o comportamento obtido com a simulação. 
Também pode envolver uma comparação da estrutura do modelo e do sistema, e 
comparações do número de vezes que decisões fundamentais ou pacotes dos subsistemas 
são realizadas. Outros modelos do mesmo sistema também podem ser utilizados na validação
9. Plano de Tática e Estratégia - refere-se ao estabelecimento das ações para a execução da 
simulação, o plano estratégico consiste em um cronograma de atividades eficiente tanto para 
explicar as relações entre os resultados simulados e as variáveis controladas, quanto para 
determinar a combinação dos valores das variáveis controladas que minimizariam ou 
maximizariam a resposta simulada. Já o plano tático consiste em determinar como cada 
simulação deve ser realizada para se obter as informações desejadas sobre os dados
Modelagem e Simulação Discreta 27
10. Experimentação e Análise dos Resultados - execução do modelo computacional, 
interpretação e análise dos resultados
11. Implementação dos Resultados - os resultados da simulação são implantados no sistema 
real e devem ser monitorados para comparar resultados da simulação com os resultados 
operacionais e fazer avaliações em nível de campo
12. Documentaçãodo Modelo - documentação do modelo utilizando os diagramas da UML ou 
equivalente
13. Relatório da Simulação - relatório técnico da simulação e memória de cálculo utilizando 
normas técnicas ou equivalente
O seguinte exemplo trata dos modelos matemáticos.
Exemplo 1.7 Por que confiamos em modelos matemáticos?
Marcelo Girardi Schappo
Quanto tempo leva para ir de carro de São Paulo ao Rio de Janeiro? Depende da velocidade 
do automóvel, certo? Quanto mais rápido nos movermos, menos tempo levaremos para 
chegar ao destino. Na escola, muita gente aprendeu uma relação chamada de “velocidade 
média”, que é a razão entre a distância e o tempo necessário para percorrê-la. Usando essa 
equação, podemos estimar a velocidade média de um carro, de um ônibus ou de um avião. 
Se, ao contrário, soubermos a velocidade média, podemos usar a mesma equação para 
determinar, aproximadamente, o tempo da viagem. Fazendo isso, estamos, na verdade, 
usando um modelo matemático simples (a definição matemática da velocidade média) 
para tentar prever determinado fenômeno (tempo de viagem de São Paulo ao Rio).
Essa é a grande importância dos “modelos” na ciência. Eles permitem fazer previsões sobre 
determinados fenômenos e processos. No caso da viagem, quanto melhor for a nossa 
estimativa inicial para a velocidade média, melhor será a previsão sobre o tempo do 
percurso. Para estimarmos da melhor forma possível esse valor, precisamos levar em conta 
um conjunto grande de parâmetros, como a possibilidade de haver congestionamentos, 
acidentes, paradas para descanso, trechos de subida ou descida, e assim por diante. Como 
não conseguimos ter certeza sobre todos esses parâmetros, nossa previsão de tempo de 
viagem, obtida pelo modelo, sempre terá uma margem de erro. Em outras palavras, toda 
modelagem possui algum grau de simplificação. A natureza é difícil demais.
Ao longo da história, cientistas têm tentado driblar essas dificuldades fazendo modelos 
cada vez mais robustos, e temos tido bastante sucesso. Veja que, atualmente, uma sonda 
lançada para outro astro do sistema solar terá seu caminho traçado com bastante precisão. 
É possível saber, de antemão, o dia e a hora da chegada ao destino final.
Os modelos são tão importantes que estão por toda a parte na ciência. Podemos usar 
modelos matemáticos em astrofísica, por exemplo, para estudar o comportamento futuro 
de um sistema de milhares de estrelas e centenas de galáxias. Como esses corpos se 
comportarão no futuro? Quantos colidirão, ou se fundirão? Quantos serão ejetados para 
fora de seus sistemas? E quanto tempo esse processo vai levar?
Modelagem e Simulação Discreta 28
Podemos também fazer previsões acertadas sobre a forma correta de produzir um circuito 
elétrico num aparelho de rádio capaz de transmitir e receber sinais eletromagnéticos, 
sustentando adequadamente as comunicações, por exemplo. Usamos modelos para fazer a 
previsão do tempo pra amanhã e para estimar cenários futuros para o clima do planeta. 
Também é possível usar modelos para reações químicas para tentar entender como elas 
ocorrem. Em uma sala de raios-X, podemos usar modelos que nos auxiliam a determinar a 
proteção adequada para diminuir a exposição do operador da máquina à radiação. Os 
exemplos são incontáveis.
Sim, a natureza é complicada, e os modelos são simplificações. Mas essas simplificações, 
embora inevitáveis, não tornam o processo pouco importante ou inútil, como todos esses 
exemplos demonstram. Modelar a natureza é um dos grandes trunfos da humanidade, por 
meio da ciência.
À medida que vamos aprendendo mais e obtendo mais dados, cientistas que trabalham 
com os modelos da área estão de prontidão para implementar esses dados e atualizar as 
previsões. Esse é o poder da ciência.
Adaptado de: Schappo, Marcelo Girardi. Por que confiamos em modelos matemáticos? Revista Questão de 
Ciência. 2020. Disponível em: <https://www.revistaquestaodeciencia.com.br/questionador-questionado/
2020/04/09/por-que-confiamos-em-modelos-matematicos>. Acesso em: 9 Abr 2020.
1.9 Revisão
(a) (b)
Figura 1.6 a) Simulação e seus conceitos e b) Modelo de Sistemas Computacionais.
O objetivo é associar os dois conceitos para Simular Sistemas Computacionais por 
computadores.
1.10 Questões 1
1. Relacione as perguntas abaixo com os estágios da construção de modelos para 
simulação de sistemas do Quadro 1.1, justificando sua resposta:
Modelagem e Simulação Discreta 29
a) Como se relacionam os resultados com os objetivos?
b) Por que o problema está sendo estudado?
c) Quais são as hipóteses e pressupostos?
d) Quais serão as respostas que o estudo espera alcançar?
2. Relacione as Figura 1.6-a e Figura 1.6-b.
3. Faça uma única figura representando as Figura 1.6-a e Figura 1.6-b.
4. Faça um resumo do texto do Quadro 1.1 com até 1000 caracteres?
5. Crie 7 palavras-chaves para o texto do Quadro 1.1?
6. Elabore um texto sobre a Figura 1.5 com até 1000 caracteres?
1.11 Questões 2
1. O que é medida? Como é feita?
2. O que é estatística?
3. O que é uma estatística?
4. O que é método científico?
5. O que caracteriza o método científico?
6. O que é uma hipótese no âmbito do método científico?
7. O que é uma teoria científica?
8. Qual a utilidade das teorias científicas?
9. O que é um experimento científico?
10. O que é conhecimento científico?
11. Como os modelos se encaixam no método científico?
12. O que é o mundo real?
13. Como se representa o mundo real?
14. O que são sistemas?
15. Como o conceito de sistema se encaixa no método científico?
16. O que são modelos do mundo real?
17. O que são modelos matemáticos do mundo real?
18. O que é dado observado? Como é obtido?
19. O que é dado simulado? Como é obtido?
20. O que é validação? Como é feita?
21. O que é verificação? Como é feita?
22. Quantos sistemas pode-se obter do mundo real?
23. Quantos modelos pode-se obter de um sistema?
24. O que é mundo exterior de um sistema?
25. Como os sistemas interagem com o mundo exterior?
26. O que são sistemas computacionais?
Modelagem e Simulação Discreta 30
27. O que é a Teoria das Filas?
28. O que são amostras representativas?
29. Como obter amostras representativas dos sistemas computacionais?
30. O que são modelos de simulação?
31. Quais são os resultados dos modelos de simulação?
32. O que é uma técnica reducionista?
33. Quais as desvantagens das técnicas reducionistas?
34. O que são critérios de qualidade estabelecidos?
35. Quem define os critérios de qualidade estabelecidos?
36. O que são sistemas gerais e orientados?
37. Sistemas baseados na Teoria das Filas são orientados? 
38. O são variáveis intrínsecas?
39. Porque o tempo é intrínseco nos sistemas geral e orientado?
40. Quais são as entradas dos sistemas baseados na Teoria das Filas?
41. Quais são as saídas dos sistemas baseados na Teoria das Filas?
42. O que são elementos irrelevantes dos sistemas?
43. Como identificar os elementos relevantes dos sistemas?
1.12 Exercícios
1. Uma caixa d’água cúbica de aresta 2 m recebe água na taxa de 2 L/s. Faça um modelo 
matemático para calcular o volume de água na água em função do tempo. Que 
suposições e simplificações são necessárias para modelar este problema e resolvê-lo? 
Como verificar e validar sua solução?
2. Uma caixa d’água, de formato cônico equilátero, recebe água na taxa x L/s. Faça um 
modelo matemático para calcular o volume de água na água no cone em função do 
tempo. Que suposições e simplificações são necessárias para modelar este problema e 
resolvê-lo? Como verificar e validar sua solução?
3. Dois automóveis, em uma estrada, distam L m um do outro. Faça um modelo 
matemático para descrever a trajetória destes veículos, sabendo que um tem o dobro 
da velocidade do outro. Quando eles se encontram? Que suposições e simplificações 
são necessárias para modelar este problema e resolvê-lo? Como verificar e validar sua 
solução?
4. Aplicar as etapas do processo de construçãode modelos nos problemas anteriores.
Modelagem e Simulação Discreta 31
2 SISTEMAS DE FILA
Os Sistemas de Fila são as unidades básicas da Simulação Discreta de Sistema 
Computacionais. Sistemas de Fila podem ser descritos como pacotes chegando para serem 
processadas e saindo do sistema após serem atendidas. A formação de Fila ocorre quando a 
procura é maior do que a capacidade de atendimento do Servidor. O fluxo temporal dos 
pacotes, chegando nas Filas, chegando e saindo dos Servidores, determina a dinâmica do 
Sistemas de Fila e seus eventos ao processar estes pacotes.
Em termos conceituais, Sistemas de Fila são compostos por uma Fila6 e por um ou 
mais Servidores, como exposto na Quadro 2.1. O Pacote é a unidade que requer 
atendimento.
Quadro 2.1 Componentes dos Sistemas de Fila
Pacote – unidade que requer atendimento
Fila – representam os pacotes que esperam atendimento, não inclui o pacote no Servidor
Servidor – canal que realizam atendimento dos pacotes da Fila
A Figura 2.1 representa graficamente a estrutura de um Sistema de Fila, nela pode-se 
ver seus componentes, suas inter-relações e seus parâmetros. Nesta figura estão 
identificados seis parâmetros básicos dos Sistemas de Fila, que são descritos no Quadro 2.2: 
1) processo de chegada; 2) distribuição do tempo de serviço; 3) número de Servidores; 4) 
capacidade do Sistema; 5) tamanho da população; 6) disciplina de Serviço.
6 Os Sistemas de Fila pode possuir mais de uma Fila mas não serão considerados neste texto.
Modelagem e Simulação Discreta 32
Figura 2.1 Representação gráfica de um Sistema de Fila com múltiplos servidores, sua 
estrutura, parâmetros básicos e inter-relações entre seus componentes (Jain, 1991).
Quadro 2.2 Os seis parâmetros básicos dos Sistemas de Fila
Parâmetro Descrição
1. Processo de 
chegada
o processo de chegada de pacotes ou entrada de pacote na Fila 
do sistema, é medido em termos de número médio de pacotes 
que chegam por unidade de tempo (λ – taxa média de chegada) 
ou pelo tempo médio entre chegadas sucessivas de pacotes (1/λ)
2. Distribuição do 
tempo de serviço
a distribuição do tempo de serviço é descrito pela taxa de serviço 
(μ) ou tempo de atendimento de um pacote (1/μ)
3. Número de 
Servidores
número de Servidores que prestam serviços simultaneamente; 
um Sistema de Fila pode possuir um ou mais canais de 
atendimento operando independentemente um do outro.
4. Capacidade do 
Sistema
número máximo de pacotes permitidos no Sistema de Fila ao 
mesmo tempo, tanto aqueles nos Servidores sendo atendidos 
quanto aqueles nas Filas esperando atendimento
5. Tamanho da 
população
tamanho potencial da população de pacotes que demandam o 
Sistema de Fila
6. Disciplina de 
Serviço
refere-se à maneira como os pacotes são escolhidos para entrar 
nos Servidores após a Fila ser formada
Os seis parâmetros dos Sistemas de Fila, apresentados na Figura 2.1 e no Quadro 2.2, 
são resumidos pela Notação de Kendall através dos símbolos A/B/c/K/m/Z, descritos no 
Quadro 2.3.
Modelagem e Simulação Discreta 33
Quadro 2.3 Descrição dos parâmetros da notação de Kendall para Sistemas de Fila e valores 
dos seus parâmetros
Símbolo Descrição Valores
A
distribuição estatística dos intervalos de 
tempo entre chegadas
M – Processo de Markov (os pacotes 
chegam e saem um de cada vez)
B
distribuição estatística do tempo de 
serviço
M – Processo de Markov
c
número de Servidores ou capacidade de 
atendimento
1, 2, …
K
número máximo de pacotes permitidas 
no sistema
1, 2, …, ∞7
m tamanho da população de pacotes 1, 2, …, ∞
Z disciplina da fila
FIFO – o primeiro que chega é o 
primeiro a ser atendido
A notação M/M/1/10/∞/FIFO indica um processo com chegadas Marcovianas, 
atendimento também Marcoviano, um Servidor, capacidade máxima do sistema igual a 10 
pacotes, população infinita e o primeiro que chega é o primeiro a sair do sistema.
A notação M/M/1 é o Sistema de Fila mais simples, com chegadas e atendimento 
Marcovianos, um Servidor, capacidade do sistema infinita, população infinita e o primeiro que 
chega é o primeiro a sair do sistema, é a abreviação de M/M/1/∞/∞/FIFO, ou seja:
M /M /1⇔M /M /1/∞/∞/FIFO
A disciplina de fila FIFO (primeiro que chega é o primeiro a sair do sistema) será a 
adotada para os Sistemas Computacionais, por ser uma simplificação razoável.
Exemplo 2.1 Escalonamento FIFO (First in First out – Primeiro a Chegar – Primeiro a Sair)
O escalonamento FIFO (não-preemptivo8) é o de implementação mais simples. Desta forma, 
o primeiro pacote que chega na Fila é o primeiro a ser enviado para o Servidor. Os pacotes 
são organizados em uma Fila, que funciona baseado na política FIFO. Considere o seguinte 
conjunto de pacotes:
Pacote na Fila Tempo de Serviço (ut)
p1 3
p2 6
p3 4
p4 5
Supondo que a ordem de chegada dos pacotes seja: p1, p2, p3 e p4. Dessa forma, conforme 
a política FIFO, a ordem de execução dos pacotes é mostrado diagrama de tempo abaixo.
7 Os valores infinitos adotados para K e m são simplificações para evitar cálculos de probabilidade com reposição, simplificam os modelos 
sem afetar suas aplicações e suas interpretações – os resultados justificam tais aproximações.
8 No escalonamento não-preemptível um pacote não pode ser retirado do Servidor.
Modelagem e Simulação Discreta 34
Para este conjunto de pacotes o tempo de espera do pacote p1 é de 0 (zero) ut; para o 
pacote p2 de 3 ut; para o pacote p3 de 9 ut; e para o pacote p4 de 13 ut. O tempo médio de 
espera na fila é de (0+3+9+13)/4, que é igual a 6,25 ut.
A disciplina de fila SJF (Shortest Job First – Menor Tarefa Primeiro), o pacote da Fila que 
tem o menor tempo de serviço é encaminhado ao Servidor, Exemplo 2.2.
Exemplo 2.2 Escalonamento SJF – Shortest Job First (Menor Tarefa Primeiro)
Neste escalonamento, o pacote da Fila que tem o menor tempo de serviço é encaminhado 
ao Servidor. Considere o seguinte conjunto de pacotes:
Pacote na Fila Tempo de Serviço (ut)
p1 3
p2 6
p3 4
p4 5
Supondo que a ordem de chegada dos pacotes seja: p1, p2, p3 e p4, e que todos eles estão 
na Fila. Conforme a política SJF, a ordem de execução dos pacotes é mostrado diagrama de 
tempo abaixo.
Neste escalonamento, o tempo de espera do pacote p1 é de 0 ut; para o pacote p3 é de 3 
ut; para o pacote p4 é de 7 ut; e para o pacote p2 é de 12 ut. O tempo médio de espera na 
Fila é de 5,5 ut, (0+3+7+12)/4.
Segundo Silberschatz, trata-se de um escalonamento ótimo, em média, neste 
escalonamento, os pacotes esperam menos para serem processados pelo Servidor.
Modelagem e Simulação Discreta 35
2.1 Sistemas de Fila M/M/1
O modelo Fila+Servidor é o mais simples dos Sistemas de Fila, possui uma única Fila e 
apenas um Servidor, a Figura 2.2 é sua representação gráfica, seu símbolo.
Figura 2.2 Representação gráfica de Sistemas de Fila simples destacando sua estrutura, os 
processos de chegada e saída, a formação da Fila com pacotes em espera na Fila e o 
Servidor.
Este modelo é a unidade básica da Simulação Discreta, embora possua estrutura 
simples, ele é bem estudado e tem sido bem-sucedido em representar o comportamento dos 
Sistemas Computacionais. Este modelo pode ser associados em série e, ou, em paralelo para 
simular Sistemas Computacionais, como circuitos integrados, componentes de hardware e 
software e rede de computadores. Ele pode ser usado para analisar os recursos individuais de 
sistemas de computação, por exemplo: se instruções a serem processadas por uma CPU são 
mantidas em uma memória. A CPU pode ser modelada por um Sistema de Fila, onde a 
memória é a Fila e a CPU é o Servidor do sistema.
Em Sistemas de Fila M/M/1, os pacotes chegam na Fila à taxa média λ, o processo de 
chegada é Marcoviano, com distribuição de probabilidade exponencial. Os pacotes são 
atendidos à taxa de serviço μ, o processo de atendimento é Marcoviano, com distribuição de 
probabilidade exponencial.
Inicialmente,o Sistemas de Fila está ocioso, não há pacote na Fila e nem no Servidor, 
isto é, a Fila está vazia e o Servidor ocioso. O primeiro pacote que chega no sistema passa 
pela Fila e vai para o Servidor. A Fila continua vazia e o Servidor fica ocupado. À medida que 
chegam mais e mais pacotes, em geral, há formação de Fila e o Servidor processa 
continuamente os pacotes que chegam.
Vale destacar que os eventos discretos, chegar na Fila, entrar no Servidor e sair do 
Servidor, serão de grande valia nos Modelos Conceitual e Computacional de Sistemas de Fila 
M/M/1.
Em Sistemas de Fila M/M/1, pode-se considerar dois tipos de grandezas para descrever 
seu comportamento. A primeira é o número de pacotes na Fila e no Servidor. A segunda é o 
tempo dos pacotes na Fila e no Servidor. Essas variáveis são aleatórias e são denominadas 
variáveis fundamentais dos Sistemas de Fila M/M/1, e estão descritas no Quadro 2.4 e 
representadas graficamente na Figura 2.3.
Modelagem e Simulação Discreta 36
Quadro 2.4 Variáveis aleatórias fundamentais dos Sistemas de Fila M/M/1 (Jain, 1991)
Variável Descrição
λ taxa média de chegada na Fila por unidade de tempo
μ taxa média de serviço por Servidor por unidade de tempo
n número de pacotes no Sistema de Fila, na Fila e no Servidor
nq número de pacotes esperando na Fila ou comprimento da Fila
ns número de pacotes no Servidor ou número de pacotes sendo atendidos
r tempo de resposta do sistema ou tempo no Sistema de Fila
w tempo de espera na Fila
s tempo de permanência no Servidor
Figura 2.3 Representação gráfica das variáveis aleatórias fundamentais dos Sistemas de Fila 
M/M/1, adaptado de Jain (1991).
Na Figura 2.3 pode-se destacar cinco níveis relacionados às variáveis aleatórias 
fundamentais dos Sistemas de Fila M/M/1, a saber:
1. no nível superior, tem-se os processos que ocorrem nestes sistemas, a chegada, a 
espera, o serviço e a saída
2. no nível abaixo, destacam-se as taxas de chegada (λ) e de serviço (μ)
3. nível intermediário, estão os números do sistema, nq, ns e n, número de pacotes na 
Fila, no Servidor e no Sistema de Fila, respectivamente, n = nq + ns
Modelagem e Simulação Discreta 37
4. no próximo nível, estão os eventos discretos do sistema, a saber, chegar na Fila, entrar 
no Servidor e sair do Servidor
5. no último nível estão os tempos do sistema, w, s e r, tempo de espera na Fila, tempo 
de permanência no Servidor e tempo total no Sistema de Fila, respectivamente, sendo 
r = w + s. O intervalo entre chegadas é a diferença entre os tempos de duas chegadas 
sucessivas.
Exemplo 2.3 Representação gráfica das variáveis aleatórias relacionadas aos eventos dos 
Sistemas de Fila M/M/1
Em termos de simulação, a entrada sucessiva 
de pacotes em um Sistema de Fila, como os pa-
cotes Pi-1 e Pi da figura ao lado, e seus três even-
tos discretos (∎ - chegar na Fila, ∎ - entrar no 
Servidor e ∎ - sair do Servidor), permitem definir 
cinco variáveis aleatórias temporais relaciona-
das à dinâmica temporal do sistema.
Considerando o mesmo pacote, temos os tem-
pos dos eventos:
∎ - chegada de pacote na Fila (cpf)
∎ - entrada de pacote do Servidor (eps)
∎ - saída de pacote do Servidor (sps)
Considerando dois pacotes sucessivos, temos os 
tempos eventos:
∎ - intervalo entre chegadas na Fila (ic)
∎ - intervalo entre saídas do Servidor (is)
Em termos de modelagem matemática:
ri = spsi – cpfi
si = spsi – epsi
wi = epsi – cpfi
ici = cpfi – cpfi-1
isi = spsi – spsi-1
Estas variáveis temporais permitem calcular as estatísticas do sistema e seu estudo deta-
lhado. 
No Quadro 2.5 estão as Leis de Little, Equações 2.1, 2.2 e 2.3. Em termos práticos, 
estas leis permitem converter valores de Tempo no Sistema em seus respectivos valores de 
Número no Sistema.
Modelagem e Simulação Discreta 38
Quadro 2.5 Estabilidade, Tempo e Número no Sistema de Fila e na Fila.
Condição de estabilidade
• λ < μ, λ e μ são variáveis aleatórias
Número no Sistema x Número na Fila
• n = nq + ns, onde n, nq e ns são variáveis aleatórias
• E[n] = E[nq] + E[ns], o número médio de pacotes no Sistema de Fila é igual à soma do 
número médio de pacotes na Fila e o número médio de pacotes no Servidor
• se a taxa de serviço é independente do número de pacotes na Fila, tem-se que 
Cov(nq,ns) = 0 e V[n] = V[nq] + V[ns]. A variância do número de pacotes no Sistema 
de Fila é igual à soma da variância do número de pacotes na Fila e a variância do 
número de pacotes no servidor
Tempo no Sistema x Tempo na Fila
• r = w + s, o tempo de permanência no Sistema de Fila é igual à soma do tempo de 
espera na Fila e do tempo de serviço, r, w e s são variáveis aleatórias
• E[r] = E[w] + E[s], o tempo médio no sistema é igual à soma do tempo médio de 
espera na Fila e do tempo médio de serviço
• se a taxa de serviço é independente do número de serviços na Fila, tem-se que 
Cov(w,s) = 0 e V[r] = V[w] + V[s], a variância do tempo de permanência no sistema é 
igual à soma das variâncias do tempo de espera na Fila e do tempo de serviço
Número no Sistema x Tempo no Sistema
• se pacotes não são perdidos devido à capacidade do sistema, o número médio de 
pacotes em um sistema está relacionado com seu tempo médio de resposta pela 
equação:
número médio de pacotes no Servidor = taxa de chegada × tempo médio de serviço
E[ns] = λ E[s] 2.1
• similarmente, o número médio de pacotes na Fila de um sistema está relacionado 
com seu tempo médio de espera pela equação:
número médio de pacotes no Servidor = taxa de chegada × tempo médio na Fila
E[nq] = λ E[w] 2.2
• da mesma forma, o número médio de pacotes no Sistema de Fila está relacionado 
com seu tempo médio no sistema pela Equação 2.3
número médio de pacotes no Sistema = taxa de chegada × tempo médio no Sistema
E[n] = λ E[r] 2.3
Modelagem e Simulação Discreta 39
A Teoria de Filas, desenvolvido por A. K. Erlang em 1909, é utilizada para descrever 
analiticamente Sistemas de Fila por meio de fórmulas matemáticas. Seu uso permite 
determinar várias medidas da efetividade destes sistemas, com a finalidade de indicar seu 
desempenho. Os resultados analíticos da Teoria das Filas aplicados em Sistemas de Fila M/M/1 
serão mostrados na próxima seção.
Exemplo 2.4 Modelagem e Simulação em Ciência e Tecnologia
Modelagem e Simulação (M&S) são importantes na Ciência & Tecnologia & Inovação pois 
são capazes de representar sistemas reais por meio de modelos matemáticos, permitem 
representar sua dinâmica por meio de simulação, explorar o seu comportamento de uma 
forma articulada que muitas vezes não é possível, ou envolve riscos no mundo real.
A M&S usa diversas áreas de Ciência da Computação, bem como são influenciadas pela 
Teoria de Sistemas, Engenharia de Sistemas e Engenharia de Software, dentre outras áreas 
do conhecimento. Esta base é tão diversa quanto a da Gestão e da Engenharia, reunindo 
elementos de arte, engenharia e ciência de uma forma complexa e única.
A M&S está calcada em modelos, que podem ser compostos de diferentes unidades 
vinculadas ao cumprimento de um objetivo específico. Por isso M&S também pode ser 
chamadas de soluções de modelagem. De modo mais geral, modelagem e simulação são 
metodologias chave para atividades de engenharia de sistemas, pois a representação de 
sistema em um modelo legível por computador permite que os engenheiros reproduzam o 
comportamento do sistema, uma maneira de apoiar as atividades de engenharia de 
sistemas em seu processo de tomada de decisão.
Fonte: Adaptado de Modeling and simulation (en.wikipedia.org/wiki/Modeling_and_simulation).
Modelagem e Simulação Discreta 40
2.2 Revisão
2.3 Questões
1. Caracterize e diferencie Sistemas de Fila, Fila e Servidor.
2. Qual é a razão para se considerar a tamanho da fila infinita?
3. Qual é a razão para se considerar a tamanho da população infinita?
4. Qual é o significado do valor λ? E o do seu inverso?
5. Qual é o significado do valorμ? E o do seu inverso?
6. Qual é a unidade de λ? E a do seu inverso?
7. Qual é a unidade de μ? E a do seu inverso?
8. Como medir os valores de λ e μ?
9. Qual é a importância da condição de estabilidade (λ < μ)?
10.Qual é a utilidade operacional da “Lei de Little”?
11.Qual é a importância do Sistema de Fila M/M/1?
12.Porque Cov(nq,ns) = 0?
13.Porque Cov(w,s) = 0?
Modelagem e Simulação Discreta 41
3 MODELO ANALÍTICO DE SISTEMAS DE FILA
Na Teoria das Filas, os pacotes entram e saem no sistema de modo aleatório. Diferentes 
pacotes chegam de modo imprevisível, ao acaso. O sistema os processa, um a um, 
demorando mais tempo com uns do que com outros. O tempo dedicado a cada pacotes 
também é imprevisível, é um tempo aleatório. Toda vez entra ou sai pacote do sistema ele 
muda de estado. Pode-se afirmar que o estado de sistema é sua quantidade de pacotes. 
Estes processos aparecem em inúmeras aplicações, como Sistemas de Filas, redes de 
comunicação de computadores e engenharia de desempenho. Nestas aplicações, os 
processos estocásticos têm estados discretos.
Seja n o número de pacotes de um Sistema de Fila M/M/1 (SF), n ≥ 0. Quando n = 0, o 
sistema está vazio ou ocioso. Neste caso, a única mudança de estado possível é chegar um 
pacote, ou seja, n = 1. Quando o sistema tem k pacotes, pode chegar um novo pacote, n = 
k+1, ou pode sair um pacote, n = k-1.
Resumindo, pacotes chegam nos SF, são processados e saem do sistema de um em um. 
Não chegam mais de um por vez9, nem são processados mais de um por vez. Seu estado é o 
seu número de pacotes, n. Seu estado pode aumentar para n+1 com a chegada de um 
pacote, ou mudar para n-1 com a saída de um pacote. Estes processos de chegada/saída de 
pacotes são denominados transições de estado.
Para representar os SFs, seus estados e suas transições, é usado o Modelo de Markov, 
uma maneira de representar sistemas e processos estocásticos do mundo real que codificam 
dependências e atingem um estado estacionário ao longo do tempo. Sistemas de Markov são 
modelados como uma sequência de estados e, a medida que o tempo passa, o sistema que 
se move entre os estados com uma probabilidade específica. Como os estados estão 
conectados, eles formam uma cadeia, essa forma de modelar o mundo é chamada de Cadeia 
de Markov.
9 Pacotes podem chegar em lotes na Fila, mais de um por vez, entretanto, esta simplificação produz modelos mais simples e sem perdas 
significativas de precisão dos resultados.
Modelagem e Simulação Discreta 42
Uma Cadeia de Markov é o tipo mais simples de Modelo de Markov, onde todos os 
estados são observáveis e as probabilidades convergem ao longo do tempo. Com isso, pode-
se descreve o comportamento de um SF ao longo do tempo. Observe que a Cadeia de Markov 
tem um único estado, o valor de n, a cada momento do tempo pode-se ter transições para 
n+1 ou n-1. Diz-se que Cadeias de Markov tem memória de curto prazo, dela pode-se saber a 
última transição (chegou ou partiu pacote) ou a próxima transição (chegará ou partirá 
pacote). Com isso, a trajetória até o estado atual não afeta a próxima transição, a única coisa 
que pode influenciar a próxima transição é o estado atual. Um outro fato observável é que, 
pode-se chegar ao estado atual de muitas maneiras diferentes, sempre combinando 
chegadas/partidas.
As Cadeias de Markov nos quais as transições são discretas e restritas aos estados 
vizinhos são Processos Nascimento Morte. Eles são utilizados para modelar sistemas nos 
quais os pacotes chegam uma de cada vez e não em lotes. Por exemplo, o número de 
pacotes em uma Fila com um único Servidor e chegadas individuais (e não em lotes) pode 
ser representada como um Processo Nascimento Morte. Uma chegada na Fila (nascimento) 
faz com que o estado mude parar n+1 e uma partida do Servidor (morte), faz com que o 
estado mude para n-1.
No contexto dos SFs, as chegadas/partidas são probabilidades condicionais e são 
denominadas probabilidades de transição. As probabilidades de transição descrevem a 
transição entre estados na cadeia como uma probabilidade condicional.
Para entender como a rotina de chegadas/partidas de pacotes evolui ao longo do tempo, 
há dois componentes a serem considerados:
▪ estado inicial (n = 0 e tempo = 0 por conveniência)
▪ número de pacotes a serem processados
▪ estado final (resultados e tomada de decisão)
Os estados futuros são condicionados pelo estado da cadeia antes de cada transição. 
Uma característica das Cadeias de Markov Regular10 é que, ao longo de um número grande o 
suficiente de iterações, todas as probabilidades de transição convergirão para um valor e 
permanecerão inalteradas. Isso significa que, após um número suficiente de iterações, a 
probabilidade de terminar em qualquer estado da cadeia é a mesma, independentemente de 
onde ela começou. E, quando a cadeia atinge este ponto, podemos dizer que as 
probabilidades de transição atingiram um estado estacionário. O intervalo de tempo em que 
a cadeia atinge um estado estacionário depende das transições possíveis entre os estados e 
de suas probabilidades.
10 Cadeias de Markov com Processos Nascimento Morte.
Modelagem e Simulação Discreta 43
Apenas Cadeias de Markov Regulares convergem com o tempo, permitindo obter 
resultados e tomar decisões a respeito dos sistemas por elas modelados. As Cadeias de 
Markov com Processos Nascimento Morte, com descritos acima, são Cadeias de Markov 
Regulares, e elas são de interesse da Engenharia pois geram resultados aplicáveis.
3.1 Modelo de Sistemas de Fila M/M/1
O Sistema de Fila M/M/1 é o mais simples, constituído por uma Fila e um Servidor, em 
que os pacotes chegam de acordo com uma Cadeia de Markov regular e o tempo para 
atendê-las é distribuído exponencialmente, Figura 3.1. O modelo também assume 
capacidade infinita do sistema, os pacotes são provenientes de uma população infinita e a 
disciplina da fila é FIFO.
A Figura 3.1 apresenta o diagrama de transição de estado de um Processo Nascimento 
Morte em um Sistema de Fila M/M/1. As Cadeia de Markov regular não são estáticas, porém 
são estáveis; o balanço entre os pacotes que entram na cadeia e os pacotes que dela saem 
tendem ao equilíbrio.
Figura 3.1 Diagrama de transição de estado de Processo Nascimento Morte.
Quando o sistema está no estado n, os novos processos chegam a taxa λn-1 e partem 
com taxa de serviço μn, n > 0. Assumindo que os intervalos entre chegadas e os tempos de 
serviço são exponencialmente distribuídos, a probabilidade de estado estacionário de um 
Processo Nascimento e Morte de estar no estado n é dada pelo Teorema 1.1.
Teorema 1.1 A probabilidade do estado estacionário pn de um processo nascimento morte 
estar no estado n, n > 0, é dada pela Equação 3.1
pn=p0
λ0λ1λ2⋯λn−2λn−1
μ1μ2μ3⋯μn−1μn
3.1
em que p0 é a probabilidade da Fila estar vazia, n = 0.
3.2 Modelo Analítico de Sistemas de Fila M/M/1
Modelagem e Simulação Discreta 44
A Fila de Sistemas de Fila M/M/1, em que os pacotes podem aumentar ou diminuir um 
pacote de cada vez. Este sistema pode ser modelado pelo Processo Nascimento Morte com 
taxas homogêneas de nascimento λ e de morte μ. O diagrama de estado das taxas de 
transição deste caso é mostrado na Figura 3.2.
Figura 3.2 Diagrama de transição de estado de Sistemas de Fila M/M/1 destacando o tamanho 
da Fila e os valores constantes das taxas de transição λ e μ.
O estado desta Fila é dado pelo seu número de pacotes n, teoricamente n ∈ [0,∞) pois a 
capacidade do sistema é infinita. Para λi = λ e μi = μ, i ∈ [0,n), o Teorema 1.1 nos dá a 
seguinte expressão para a probabilidade de n pacotes do sistema:
3.2
A quantidade λ/μ é chamada de intensidade de tráfego e é indicada pelo símbolo ρ. 
Assim,
ρ=λμ 3.3
pn=p0ρ
n 3.4
Uma vez que a soma de todas probabilidades deve ser iguala 1, tem-se a seguinte 
expressão para a probabilidade de zero pacotes na Fila do sistema, cuja demonstração está 
no Capítulo 16 :
3.5
Substituindo p0 em pn, obtém-se:
pn=(1−ρ)ρ
n 3.6
A Utilização do Servidor é dada pela probabilidade de se ter um ou mais pacotes no 
sistema:
U=1−p0=ρ 3.7
Quando não há pacotes no sistema, o Servidor é dito ocioso; caso contrário, o Servidor 
está ocupado. O intervalo de tempo entre dois sucessivos intervalos ociosos é chamado de 
período ocupado.
No Quadro 3.1 estão os resultados do Modelo Analítico da Teoria das Filas aplicados a 
Sistemas de Fila M/M/1. Estas estatísticas são obtidas a partir das equações acima 
pn=p0
λn
μn
p0=1−ρ
Modelagem e Simulação Discreta 45
(demonstração no Capítulo 16 ), seu uso permite determinar várias medidas da efetividade 
destes sistemas, com a finalidade de indicar seu desempenho.
Quadro 3.1 Resultados do Modelo Analíticos de Sistemas de Fila M/M/1 segundo a Teoria das 
Filas (Jain, 1991)
- Parâmetros λ, μ
- Intensidade de tráfego ρ=λμ
- Condição de estabilidade ρ<1
1 Probabilidade de zero pacote no Sistema de Fila p0=(1−ρ)
2 Probabilidade de n pacotes no Sistema de Fila pn=(1−ρ)ρ
n , n∈ℕ
3 Número médio de pacotes no Sistema de Fila E[n]= ρ
1−ρ
4 Variância do número médio de pacotes no Sistema de Fila V [n]= ρ
(1−ρ)2
5 Probabilidade de nq pacotes na Fila P[nq]={ 1−ρ2 , nq=0
(1−ρ)ρnq+1 , nq>0
6 Número médio de pacotes na Fila E[nq ]=
ρ2
1−ρ
7 Variância do número médio de pacotes na Fila V [nq]=
ρ2(1+ρ−ρ2)
(1−ρ)2
8 FDA do tempo de resposta F(r)=1−e−μ(1−ρ)r
9 Tempo médio de resposta E[r ]= 1
μ(1−ρ)
10 Variância do tempo de resposta V [r ]= 1
μ2(1−ρ)2
11 Percentil q do tempo de resposta wq=E [r ] ln( 100
100−q
)
12 Percentil 90 do tempo de resposta w90=2,3 E[r ]
13 FDA do tempo de espera F(w)=1−ρ e−μ(1−ρ)w
14 Tempo médio de espera E[w ]= ρ
μ(1−ρ)
=ρ E[r ]
15 Variância do tempo de espera V [w]=
(2−ρ)ρ
μ2(1−ρ)2
16 Percentil q do tempo de espera max {0 ,
E [w ]
ρ ln(
100ρ
100−q
)}
17 Percentil 90 do tempo de espera max {0 ,
E [w ]
ρ ln(10ρ)}
Modelagem e Simulação Discreta 46
18 Probabilidade de n ou mais pacotes no Sistema de Fila ρn
19 Probabilidade de executar n pacotes no período ocupado
1
n (2n−2
n−1 )ρn−1− 1
(1+ρ)2n−1
20 Número médio de pacotes executadas no período
1
1−ρ
21 Variância do número médio de pacotes executados no período
ρ(1+ρ)
(1−ρ)3
22 Duração média do período
1
μ(1−ρ)
23 Variância da média do período
1
μ2(1−ρ)3
− 1
μ2(1−ρ)2
Os resultados analíticos apresentados no Quadro 3.1 estão discutidos no Capítulo 16 .
O seguinte exemplo ilustra a aplicação destes resultados na modelagem de um gateway 
de rede, extraído de Jain (1991).
Exemplo 3.1 Em um gateway de uma rede, medições mostraram que os pacotes chegavam 
a uma taxa média de 125 pacotes por segundo (pps) e o gateway leva cerca de 2 
milissegundos para transmiti-los. Usando um modelo M/M/1, analise o gateway. Qual é a 
probabilidade de estouro de buffer se o tamanho do buffer do gateway for igual a 13? Qual 
a tamanho do buffer para que a perda de pacotes seja menor do que um pacote por 
milhão?
Taxa de chegada λ = 125 pps
Taxa de serviço µ = 1/0,002 = 500 pps
Intensidade do tráfego no gateway ρ = λ/μ = 0,25
Probabilidade de n pacotes no gateway = (1-ρ)ρn = 0,75(0,25)n
Número médio de pacotes no gateway = ρ/(1-ρ)= 0,25/0,75 = 0,33
Tempo médio gasto no gateway = (1/µ)/(1-ρ)= (1/500)/(1-0,25)=2,66 ms
Probabilidade de estouro de buffer = P(n > 13 pacotes no gateway) = ρn = 0,2513= 
1,49x10-8 ≈ 15 pacotes por bilhões de pacotes
Para limitar a probabilidade de perda de pacotes para menos de 1x10-6, ρn < 1x10-6 ou
n > ln(1x10-6)/ln(0,25) = 9,96.
Conclusão: o tamanho do buffer deve ser igual a 10.
Os dois últimos resultados sobre estouro de buffer são aproximados. Estritamente falando, 
o gateway deve ser modelado como uma fila M/M/1/B, em que B é o tamanho do buffer. No 
entanto, uma vez que a utilização é baixa e o tamanho do buffer está acima do 
Modelagem e Simulação Discreta 47
comprimento médio da fila, estes resultados são boas aproximações.
3.3 Revisão
3.4 Questões
1. O que são Cadeias de Markov?
2. O que são Cadeias de Markov regular?
3. Qual o significado de “Cadeias de Markov regulares convergem com o tempo”?
4. Qual o significado de “resultados de Cadeias de Markov regulares com um número 
muito grande de pacotes são independentes do estado inicial”? Qual sua importância 
na Engenharia?
5. Qual a importância dos Processos Nascimento Morte no Modelo Analítico de Sistemas 
de Fila M/M/1?
6. Qual a importância das taxas homogêneas de nascimento (λ) e de morte (μ) no Modelo 
Analítico de Sistemas de Fila M/M/1?
7. Qual a utilidade das variáveis do Quadro 3.1 para o engenheiro?
8. Compare as Figura 3.1 e Figura 3.2.
9. De uma interpretação operacional para a Utilização do Servidor.
10.De uma interpretação operacional para “perda de pacotes menor do que um pacote 
por milhão”?
Modelagem e Simulação Discreta 48
11.Dê um exemplo de modelo matemático usado para avaliar o desempenho acadêmico 
de graduandos. Comente sobre suas deficiências? Por que são usados?
12.Como é calculado o preço do dólar americano em reais?
13.Como é calculada a inflação mensal da nossa moeda?
14.Qual a diferença entre uma opinião técnica e um modelo matemático?
15.Quando p0 tende a 0 como se comporta E[nq]?
16.Quando p0 tende a 1 como se comporta E[nq]?
17.Relacione este comentário com a temática deste capítulo: “Há muita matéria no 
universo – muita mesmo. É uma quantidade difícil até mesmo de ser mensurada. No 
entanto, a matemática nos permite fazer magia, e é completamente possível calcular a 
quantidade total de matéria no universo … [mas é necessário ferramentas que 
possibilitam] comparações do mundo teórico com o mundo prático”. Adaptado de 
Felipe Miranda, 2020 (socientifica.com.br/cientistas-medem-com-precisao-a-
quantidade-total-de-materia-no-universo).
3.5 Exercícios
1. Pacotes que chegam em um Sistema de Fila M/M/1 com intervalo entre chegadas λ = { 
8, 5, 12, 15, 8, 11, 9, 10, 7, 6 } e tempos de serviço μ = { 11, 10, 9, 12, 9, 11, 14, 8, 9, 
10 }, calcule os resultados analíticos deste sistema conforme o Quadro 3.1.
2. Compare os resultados analíticos do exercício 2 considerando os seguintes cenários:
3. a) aumento de λ em 10% e redução de μ em 10%
4. b) redução de λ em 10% aumento de μ em 10%
5. c) aumento de λ em 10% e aumento de μ em 10%
6. Repita o Exemplo 3.1 para pacotes que chegam a uma taxa média de 600 pps em um 
gateway que processa um pacote em 1 milissegundo.
7. Qual a tamanho do buffer para que a perda de pacotes em um gateway (λ = 800 pps e 
µ = 700 pps) seja menor do que um pacote por milhão?
Modelagem e Simulação Discreta 49
4 MODELO CONCEITUAL DE SISTEMAS DE FILA
O modelos de Sistemas de Fila A/B/c/K/m/Z podem ser simulados por computador e, para 
isso, é necessário desenvolver os modelos conceituais e computacionais destes sistemas. 
Inicialmente, por uma questão de simplicidade, será desenvolvida uma metodologia para 
realizar simulação de Sistemas de Fila M/M/1.
A Figura 4.1 ilustra a representação gráfica de Sistemas de Fila M/M/1 e seus elementos 
constituintes: o Sistema de Fila (SF), uma Fila (F) e um Servidor (S). Os pacotes chegam na 
Fila, um por vez, o Servidor os processam também um por vez. Um pacote aguardará na Fila 
se o Servidor estiver ocupado, caso contrário, será atendido. Uma vez atendido, o pacote 
deixa o Sistema de Fila.
Figura 4.1 Modelo de Sistemas de Filas M/M/1 (SF) e seus elementos constituintes: a Fila (F), o 
Servidor (S) e os pacotes aguardando processamento (retângulos cinzas).
A partir do Sistema de Fila M/M/1, pode-se derivar modelos dos demais Sistemas de Fila 
M/M/c/K/m. Embora simples, os Sistemas de Fila M/M/1 fornecem informações úteis sobre o 
desempenho de sistemas reais.
Primeiramente será apresentado e discutido o ModeloConceitual dos Sistemas de Fila 
M/M/1 e, em seguida, o seu Modelo Computacional será apresentado e implementado em C+
Modelagem e Simulação Discreta 50
+ e Javascript. Por fim, será simulado e apresentado seus resultados na forma dum quadro. A 
dinâmica temporal dos resultados também será apresentada em HTML5, permitindo o 
acompanhamento gráfico de suas variáveis de entrada, de estado, de saída e suas 
estatísticas.
Conforme representadas na Figura 3.2 e descritas no Quadro 2.4 (capítulo anterior), as 
variáveis aleatórias fundamentais dos Sistemas de Fila para sua modelagem são seus 
eventos discretos: chegar na Fila, entrar no Servidor e sair do Servidor; e as estimativas dos 
valores a eles associados: tempo entre chegadas e o tempo de serviço.
Os pacotes chegam nos Sistemas de Fila um por vez e são processadas em um Servidor 
também um por vez. Os pacotes não chegam em lotes nem são processadas em lotes. Desta 
forma, os Sistemas de Fila possuem as variáveis básicas:
Variável Descrição
τ
tempo entre chegadas, isto é, o intervalo de tempo entre duas chegadas 
sucessivas
λ taxa média de chegada por unidade de tempo
s
tempo de serviço, tempo requerido para processar um pacote ou tempo no 
Servidor
μ taxa média de serviço do Servidor por unidade de tempo
1. a relação entre a taxa de chegada (λ) e o intervalo entre chegadas (τ) é λ = 1/E[τ]11
2. a relação entre a taxa de serviço (μ) e o tempo de serviço (s) é μ = 1/E[s]
A Figura 4.2 ilustra o Modelo Conceitual de Sistemas de Fila M/M/1 adaptado de Jain 
(1991) e nela pode-se destacar cinco níveis:
1. no nível superior, tem-se os processos que ocorrem nestes sistemas, a chegada, a 
espera, o serviço e a saída
2. no nível abaixo, destacam-se as taxas de chegada (λ) e de serviço (μ)
3. nível intermediário, estão os números do sistema, nf, ns e nsf, número de pacotes na 
Fila (F), no Servidor (S) e no Sistema de Fila (SF), respectivamente, sendo nsf = nf + ns 
4. no próximo nível, estão os eventos discretos do sistema, a saber, tempo de chegada na 
Fila (cpf), início do serviço no Servidor (eps) e fim do serviço no Servidor (sps)
5. no último nível estão os tempos do sistema, tf, tps e tsf, tempo de espera na Fila, 
tempo de permanência no Servidor e tempo total no Sistema de Fila, respectivamente, 
11 O símbolo E(x) é a esperança matemática ou valor esperado da variável aleatória x. Dada uma fdp f(x) ou p(x i), E(x) pode ser calculada 
pelas equações E (X )=∫
−∞
+∞
x f (x )dx , X∈ℝ e E (X )=∑
i=1
n
xi p(xi ), X∈ℕ , respectivamente.
Modelagem e Simulação Discreta 51
sendo tsf = tf + tps. O intervalo entre chegadas é a diferença o tempo de chegada e 
o tempo da chegada anterior.
Figura 4.2 Modelo Conceitual de Sistemas de Fila M/M/1 com seus processos, variáveis de 
entrada e saída, números e eventos em cinco níveis, adaptado de Jain (1991).
Os valores que ns pode assumir são 0 ou 1, correspondendo a Servidor ocioso ou 
Servidor ocupado, respectivamente. Os valores que nf pode assumir são os inteiros positivos, 
nf ∈ [0,∞), temos também que nsf = nf + ns. As variáveis cpf, eps e sps, são as variáveis de 
estado do sistema, são eventos discretos no tempo. Para o mesmo evento tem-se que sps ≥ 
eps ≥ cpf ≥ 0.
A Figura 4.2 é uma ilustração estática do Modelo Conceitual de Sistemas de Fila M/M/1. 
Mas nela está implícito os aspectos dinâmicos deste modelo. Pacotes chegam continuamente 
no sistema, os pacotes chegam na Fila um a um, são encaminhados para o Servidor e, após 
serem processadas, saem do sistema. Este fluxo permite gerar um quadro com os valores de 
cpf, eps e sps12, discutida abaixo13.
O Exemplo 4.1 é uma aplicação do Modelo Conceitual de Sistemas de Fila M/M/1 com 
suas entradas (ic = 1/λ e ts = 1/μ), os tempos de eventos (cpf, eps e sps) são suas 
variáveis de estado e a dinâmica do sistema obtida a partir dos seus eventos (chegada, início 
do serviço e fim do serviço). A partir dos valores destas variáveis é simulado um Sistema de 
Fila M/M/1 com 12 pacotes.
12 Os valores de cpf, eps e sps iniciam em 0 e são calculados atá o fim da simulação.
13 As variáveis aleatórias, intervalo médio entre chegadas sucessivas (ic) e o tempo médio para processar um pacote (ts), é que são usa-
das no Modelo Conceitual de Sistema de Fila M/M/1. Seus valores são ic = 1/λ e ts = 1/μ. A unidade adotada tanto para λ quanto para μ 
é pacote/segundo (p/s ou pps) – taxa temporal. A unidade tanto de ic quanto de ts é segundo/pacote (s/p) – a frequência destes proces-
sos.
Modelagem e Simulação Discreta 52
Exemplo 4.1 Sejam N = 12 pacotes que chegam em um Sistema de Fila M/M/1 com 
intervalo entre chegadas ic ={ 8, 3, 7, 4, 6, 7, 5, 8, 3, 10, 6, 5 } e tempos de serviço:
ts = { 4, 2, 6, 3, 7, 7, 5, 4, 4, 9, 6, 2 } ic e ts em segundos (s). A simulação do sistema é 
feita conforme mostrado no Quadro 4.1.
Os pacotes (p), seus intervalos entre chegadas (ic) e tempos de serviço (ts) são 
organizados segundo a ordem de chegada a partir do tempo zero, p = 1, 2, …, N, como 
mostrado no Quadro 4.1.
Quadro 4.1 Simulação de um Sistema de Fila M/M/1
p ic ts cpf eps sps
1 8 4 8 8 12
2 3 2 11 12 14
3 7 6 18 18 24
4 4 3 22 24 27
5 6 7 28 28 35
6 7 7 35 35 42
7 5 5 40 42 47
8 8 4 48 48 52
9 3 4 51 52 56
10 10 9 61 61 70
11 6 6 67 70 76
12 5 2 72 76 78
O Quadro 4.1 é preenchido calculando os valores dos tempos, em segundos, dos três 
eventos a seguir:
• cpf – tempo da chegada do pacote na Fila
• eps – tempo da chegada do pacote no Servidor, início do serviço
• sps – tempo da saída do pacote do Servidor, fim do serviço
Início da simulação: Fila vazia, Servidor ocioso e cronômetro zerado (t = 0)
• cpf0 = eps0 = sps0 = 0
p ic ts cpf eps sps
0 0 0
Primeiro pacote:
p ic ts cpf eps sps
0 0 0
1 8 4 8 8 12
• p = 1
Modelagem e Simulação Discreta 53
Exemplo 4.1 Sejam N = 12 pacotes que chegam em um Sistema de Fila M/M/1 com 
intervalo entre chegadas ic ={ 8, 3, 7, 4, 6, 7, 5, 8, 3, 10, 6, 5 } e tempos de serviço:
ts = { 4, 2, 6, 3, 7, 7, 5, 4, 4, 9, 6, 2 } ic e ts em segundos (s). A simulação do sistema é 
feita conforme mostrado no Quadro 4.1.
• ic1 = 8 s, ts1 = 4 s
• cpf1 = cpf0 + ic1 = 8 s, Fila vazia
• eps1 = cpf1 = 8 s, Servidor ocioso 
• sps1 = eps1 + ts1 = 12 s
Segundo pacote:
p ic ts cpf eps sps
1 8 4 8 8 12
2 3 2 11 12 14
• p = 2
• ic2 = 3 s, ts2 = 2 s
• cpf2 = cpf1 + ic2 = 8 + 3 = 11 s
• eps2 = 12 s, depois que p1 saiu do sistema, não antes 
• sps2 = eps2 + ts2 = 12 + 2 = 14 s
Terceiro pacote:
p ic ts cpf eps sps
1 8 4 8 8 12
2 3 2 11 12 14
3 7 6 18 18 24
• p = 3
• ic3 = 7 s, ts3 = 6 s
• cpf3 = cpf2 + ic3 = 11 + 7 = 18 s
• eps3 = 18 s, o Servidor estava ocioso 
• sps3 = eps3 + ts3 = 18 + 6 = 24 s
Quarto pacote:
p ic ts cpf eps sps
1 8 4 8 8 12
2 3 2 11 12 14
3 7 6 18 18 24
4 4 3 22 24 27
• p = 4
• ic4 = 4 s, ts4 = 3 s
• cpf4 = cpf3 + ic4 = 18 + 4 = 22 s
• eps4 = 24 s, Servidor ocioso 
Modelagem e Simulação Discreta 54
Exemplo 4.1 Sejam N = 12 pacotes que chegam em um Sistema de Fila M/M/1 com 
intervalo entre chegadas ic ={ 8, 3, 7, 4, 6, 7, 5, 8, 3, 10, 6, 5 } e tempos de serviço:
ts = { 4, 2, 6, 3, 7, 7, 5, 4, 4, 9, 6, 2 } ic e ts em segundos (s). A simulação do sistema é 
feita conforme mostrado no Quadro 4.1.
• sps4 = eps4 + ts4 = 24 + 3 = 27 s
Quinto pacote:
p ic ts cpf eps sps
1 8 4 8 8 12
2 3 2 11 12 14
3 7 6 18 18 24
4 4 3 22 24 27
5 6 7 28 28 35
• p = 5
• ic5 = 6 s, ts5 = 7 s
• cpf5 = cpf4 + ic5 = 22 + 6 = 28 s
• eps5 = 28 s, Servidor ocioso 
• sps5 = eps5 + ts5 = 28 + 7 = 35 s
E assim por diante.
O Exemplo 4.2 simula um Sistema de Fila M/M/1 com 10 pacotes.
Exemplo 4.2 Sejam N = 10 pacotes que chegam em um Sistema de Fila M/M/1 com 
intervalo entre chegadas ic = { 8, 5, 12, 15, 8, 11, 9, 10, 7, 6 } e tempos de serviço
ts = { 11, 10, 9, 12, 9, 11, 14, 8, 9, 10 }, ic e ts em segundos (s). A simulação do sistema 
é feita conforme mostrado no Quadro 4.2.
Quadro4.2 Simulação de um Sistema de Fila M/M/1
p ic ts cpf eps sps
0 0 0
1 8 11 8 8 19
2 5 10 13 19 29
3 12 9 25 29 38
4 15 12 40 40 52
5 8 9 48 52 61
6 11 11 59 61 72
Modelagem e Simulação Discreta 55
Exemplo 4.2 Sejam N = 10 pacotes que chegam em um Sistema de Fila M/M/1 com 
intervalo entre chegadas ic = { 8, 5, 12, 15, 8, 11, 9, 10, 7, 6 } e tempos de serviço
ts = { 11, 10, 9, 12, 9, 11, 14, 8, 9, 10 }, ic e ts em segundos (s). A simulação do sistema 
é feita conforme mostrado no Quadro 4.2.
7 9 14 68 72 86
8 10 8 78 86 94
9 7 9 85 94 103
10 6 10 91 103 113
Os pacotes (p), seus intervalos entre chegadas (ic) e tempos de serviço (ts) são 
organizados segundo a ordem de chegada a partir do tempo zero, p = 1, 2, …, N. O Quadro
 4.2 preenchido calculando os valores das quatro variáveis a seguir:
• cpf – tempo da chegada do pacote na Fila
• eps – tempo da chegada do pacote no Servidor, início do serviço
• sps – tempo da saída do pacote do Servidor, fim do serviço
Início da simulação: Fila vazia, Servidor ocioso e cronômetro zerado
• cpf0 = eps0 = sps0 = 0
Primeiro pacote:
• p = 1
• ic1 = 8, ts1 = 11
• cpf1 = cpf0 + ic1 = 8, Fila vazia
• eps1 = tif1 = 8, Servidor ocioso 
• sps1 = eps1 + ts1 = 19 
Segundo pacote:
• p = 2
• ic2 = 5, ts2 = 10
• cpf2 = cpf1 + ic2 = 13
• eps2 = 19, depois que p1 saiu do sistema, não antes 
• sps2 = eps2 + ts2 = 29 
Terceiro pacote:
• p = 3
• ic3 = 12, ts3 = 9
• cpf3 = cpf2 + ic3 = 25
Modelagem e Simulação Discreta 56
Exemplo 4.2 Sejam N = 10 pacotes que chegam em um Sistema de Fila M/M/1 com 
intervalo entre chegadas ic = { 8, 5, 12, 15, 8, 11, 9, 10, 7, 6 } e tempos de serviço
ts = { 11, 10, 9, 12, 9, 11, 14, 8, 9, 10 }, ic e ts em segundos (s). A simulação do sistema 
é feita conforme mostrado no Quadro 4.2.
• eps3 = 29, depois que p2 saiu do sistema, não antes 
• sps3 = eps3 + ts3 = 38
Quarto pacote:
• p = 4
• ic4 = 15, ts4 = 12
• cpf4 = cpf3 + ic4 = 40
• eps4 = 40, servidor ocioso 
• sps4 = eps4 + ts4 = 38 
E assim por diante.
4.1 Dados de Entrada para Simulação
Os dados de entrada para a simulação de Sistemas de Fila M/M/1 são a taxa média de 
chegada ou os valores de ic de cada pacote e também a taxa média de serviço ou os valores 
de ts de cada pacote. As unidades de ic e ts são segundo/pacote (s/p). Os valores de ic = 1/λ 
e ts = 1/μ.
O número de simulação (N) também é um dado de entrada. No Quadro 4.2 foram 
simulados 10 pacotes. O valor adequado de N será estudado mais adiante.
O valor de ic depende do modelo de negócio. O tamanho do pacote, usado para calcular 
o valor de ts, depende do serviço prestado, que depende também do modelo de negócio.
Dados medidos podem ser encontrados na web. O infográfico da Nasdaq de 2020 e 2021 
apresentados na Figura 4.3, é o tráfego por minuto de plataformas e aplicativos mundiais 
Modelagem e Simulação Discreta 57
nestes anos. Com estes dados pode-se estimar o valor de ic destas plataformas e aplicativos, 
como mostra o Exemplo 4.3.
(a) (b)
Figura 4.3 Tráfego em plataformas e aplicativos a cada minuto em: (a) 2020 e (b) 2021 
(Domo 8, 2020; Domo 9, 2021).
A estimativa de taxas de chegada (λ) pode ser feita com dados de várias fontes. O 
Exemplo 4.3 apresenta os valores de λ das plataformas Amazon, Facebook, Zoom e 
Instagram, calculados a partir dos dados da Figura 4.3a.
Exemplo 4.3 Com os dados da Figura 4.3a, referente ao tráfego por minuto de plataformas 
e aplicativos mundiais no ano de 2020, pode-se estimar o valor de ic destas plataformas e 
aplicativos, como ilustra o quadro a seguir.
Plataforma Pacotes por Minuto λ (p/s) ic (s/p)
Amazon 6.659 111 0,00900
Facebook 150.000 2.500 0,000400
Zoom 208.333 3.472 0,000288
Instagram 347.222 5.787 0,000173
A estimativa de tamanho de pacotes (p) pode ser feita com dados de várias fontes. O 
Exemplo 4.4 calcula o tamanho máximo dos pacotes do aplicativo Instagram a partir dos 
dados das regras de negócio da plataforma.
Exemplo 4.4 Estimativa o tamanho máximo de um pacote da plataforma Instagram
Comprimentos máximos de itens de uma mensagem do aplicativo Instagram, em 
Modelagem e Simulação Discreta 58
caracteres, são destacados abaixo14:
• legendas: 2.200 caracteres
• hashtags: 30 hashtags de até 24 caracteres
• biografia: 150 caracteres
• nome de usuário: 30 caracteres
Tamanho máximo de um pacote do Instagram = 2200 + 30 x 24 + 150 + 30 B = 3100 B ≈ 
3 KB
Vale destacar que pacotes são partes dos protocolos de comunicação. Quando os pacotes 
são muito pequenos, o tamanho dos protocolos de comunicação não precisa ser 
considerado.
O Exemplo 4.5 avalia a influência do protocolo de comunicação da Internet no cálculo do 
tamanho máximo dos pacotes do aplicativo Instagram, estimado no Exemplo 4.4.
Exemplo 4.5 Estimar o tamanho máximo de um pacote do Instagram em tráfego na 
Internet
Incluindo, a título de exemplo, o pacote máximo do Instagram no protocolo IPv6, temos:
• datagrama do protocolo IPv6 = 320 b = 40 B
• pacote do Instagram = 3100 B
Tamanho do pacote em trafego IPv6 = 3140 B
O protocolo IPv6 representa 1,3% do tamanho do pacote final.
O Exemplo 4.6 calcula o tamanho máximo dos pacotes do aplicativo Twitter a partir dos 
dados das regras de negócio da plataforma, considerando a influência do protocolo de 
comunicação da Internet no cálculo do tamanho máximo dos seus pacotes.
Exemplo 4.6 Estimar o tamanho máximo de um pacote do Twitter?
Comprimentos máximos de itens de uma mensagem do aplicativo Twitter, em caracteres, 
são destacados abaixo (sem DM)15:
• Tuíte: 140 caracteres
• Usuário: 15 caracteres
• Nome de perfil: 20 caracteres
Tamanho máximo de um pacote do Twitter = 140 + 15 + 20 B = 175 B
Observe que o datagrama do IPv6 (40 B) deve ser inserido no pacote do Twitter para fins de 
tráfego na Internet, desta forma, o pacote final terá 215 B.
14 Fonte: https://sproutsocial.com/insights/contador-de-caracteres-nas-redes-sociais/#instagram
15 Fonte: https://sproutsocial.com/insights/contador-de-caracteres-nas-redes-sociais/#twitter
Modelagem e Simulação Discreta 59
O protocolo IPv6 representa 18,6% do tamanho do pacote final, o que é considerável.
A estimativa da taxa de serviço (μ) pode ser feita a partir dos dados do Sistema 
Computacional e do pacote. O Exemplo 4.7 calcula a taxa de serviço e tempo de serviço da 
memória RAM GDDR6X, que possui taxa de transferência de 19 Gb/s, para processar pacotes 
de 5 MB.
Observe no Exemplo 4.7 que a taxa de transferência é em Gb/s e que a taxa de serviço é 
em p/s. O tamanho do pacote permite converter Gb/s em p/s.
Exemplo 4.7 A memória RAM GDDR6X da Nvidia GeForce RTX 3080 tem taxa de 
transferência de 19 Gb/s. Qual o tempo de serviço desta RAM para pacotes de 5 MB? 
Tamanho do pacote = 5 MB
Taxa de serviço:
μ=19Gb /s=19
Gb
s
pacote
pacote
= 19Gb
pacote
pacote
s
=19Gb
5MB
pps=19×1024 Mb
5 M×8b
=486,4 pps
Tempo de serviço: ts=1
μ=
1
486,4 pps
=0,00205 s / p
Ou seja, esta memória pode transferir, aproximadamente, 486 pacotes de 5 MB a cada 
segundo; o tempo requerido para transferir um único pacote de 5 MB é 0,00205 s.
O Exemplo 4.8 estima os valores de ts, de leitura e de gravação, da HD Samsung 860 
EVO.
Exemplo 4.8 Sabe-se que a HD Samsung 860 EVO de 1 TB, com 550 MB/s (leitura 
sequencial) e 520 MB/s (escrita sequencial) está sendo usada para leitura e gravação de 
arquivos de tamanhos médio iguais a 2,5 MB. Qual o tempo de serviço (ts) desta HD 
quando usada para leitura (tsleitura)? Qual o valor de tsgravação? Qual o tempo de serviço médio 
desta HD?
Tamanho do pacote = 2,5 MB
Taxa de serviço (leitura):
μleitura=550MB /s=550 MB /s pacote
pacote
=550 MB
pacote
pacote
s
=550 MB
2,5MB
pacote
s
=220
pacote
s
=220 pps
Taxa de serviço (gravação): μgravação=520MB /s=520 MB /s pacote
pacote
=208
pacote
s
=208 pps
Taxa de serviço média: μ=
μleitura+μgravação
2
=214 pps
Tempo de serviço (leitura): tsleitura=
1
μ leitura
= 1
220 pps=0,00455 s/ p
Tempo de serviço (gravação): tsgravação=
1
μgravação
= 1
208 pps
=0,00481 s/ p
Tempo de serviço médio: ts=1
μ=
1
214 pps
=0,00467 s/ p
Modelagem e Simulação Discreta 60
O Exemplo 4.9 estima o valor de ts da Nvidia GeForce RTX 3080 para processar matrizes 
usando algoritmos convencionais.
Exemplo 4.9 A Nvidia GeForce RTX 3080 tem taxa bruta de 29,77 Teraflops (TFLOPS16) de 
performance computacional. Qual o tempo de serviço desta placa para multiplicação de 
matrizes quadradas de tamanho 5.000?
O tempo de execução para a multiplicação de matrizes quadradas de ordem n é O(n³) – 
algoritmos convencionais.
Tamanho do pacote = 5000³= 1,25x1011 FLOP
Taxa de serviço:
μ=29,77TFLOPS=29,77TFLOP
s
pacote
pacote
=29,77TFLOP
pacote
pps= 29,77 1012FLOP
1,25×1011 FLOP
pps=238,2 pps 
Tempo de serviço: ts=1
μ=
1
238,2 pps
=0,00420 s / p 
Ou seja, esta placa pode multiplicar, aproximadamente, 238 matrizes quadradas de ordem 
5.000 a cada segundo, a duração de uma única multiplicação é 0,00420 s. 
O Exemplo 4.10 estima o valor de ts da Nvidia GeForce RTX 3080 para processar 
matrizes usando o algoritmo de Strassen.
Exemplo 4.10 A Nvidia GeForce RTX 3080 tem taxa bruta de 29,77 Teraflops (TFLOPS) de 
performance computacional. Qual o tempo de serviço desta placa para multiplicação de 
matrizes quadradas de tamanho 5.000 utilizando o algoritmo de Strassen ≈ O(n2,807)?
O tempo de execução para a multiplicação de matrizes quadradas de ordem n é O(n³) – 
algoritmos convencionais.
Tamanho do pacote = 50002,807= 24,2x109 FLOP
Taxa de serviço:
μ=29,77TFLOPS=29,77TFLOP
s
pacote
pacote
=29,77TFLOP
pacote
pps=29,77 1012FLOP
24,2×109FLOP
pps=1230,2 pps 
Tempo de serviço: ts=1
μ=
1
1230,2 pps
=0,000813 s / p 
Ou seja, o algoritmo de Strassen e esta placa podem multiplicar, aproximadamente, 1.230 
matrizes quadradas de ordem 5.000 a cada segundo, a duração de uma única multiplicação 
é 0,000813 s. 
16 FLOPS - FLoating-point Operations per Second (operações de ponto flutuante por segundo), usado para determinar o desempenho de um 
computador, especificamente no campo de cálculos científicos; similar a instruções por segundo.
Modelagem e Simulação Discreta 61
4.2 Valores Iniciais da Simulação
O estado inicial do Sistema de Fila é de Fila vazia e Servidor ocioso17 (nf = ns = 0). Para 
iniciar a contagem do tempo, o cronômetro é zerado (cpf = eps = sps = 0). No Quadro 4.2, 
após 8 s chega o primeiro pacote (p = 1, ic = 8 s/p, ts = 11 s/p), ele chega na Fila em cpf = 
8 s. Como o Servidor está ocioso, ele recebe o pacote em eps = 8 s e demora 11 s para 
processá-lo, assim sps = 8+11 = 19 s.
Generalizando, os seguintes comandos resumem os valores iniciais das variáveis do 
Sistemas de Fila para p = 1:
1. eps[1] = cpf[1] = ic[1]
2. sps[1] = eps[1] + ts[1]
Para fins computacionais, uma maneira prática de tratar o primeiro pacote é fazer
ic = ts = cpf = eps = sps = nf = ns = 0
4.3 Cálculo de cpf
Quando o segundo pacote chega na Fila do sistema no Erro: Origem da referência não
 encontrada (p = 2, ic = 5 s, ts = 10 s/p), o tempo transcorrido é a soma dos ic dos pacotes 
anteriores, neste caso são 8+5 = 13 s/p. Esta soma é armazenada em cpf, logo cpf[2] = 
cpf[1] + ic[2] = 8 + 5 = 11 s/p.
Generalizando, cpf[p] = cpf[p-1] + ic[p], p ∈ [2,N].
17 O estado inicial do Sistema de Fila para o início da simulação (Fila vazia, Servidor ocioso, cronômetro zerado) é de ordem prática e bus-
ca contornar as condições iniciais reais do sistema. Como consequência, a simulação apresenta grande variabilidade nos resultados ini-
ciais, denominado período transiente, no qual observa-se fortes flutuações nos valores simulados com tendência de crescimento. Em 
seguida, o comportamento da simulação apresentam flutuações menores e em torno de valores médios, é o denominado período estaci-
onário.
Modelagem e Simulação Discreta 62
4.4 Cálculo de eps
Quando o segundo pacote chega no Sistema de Fila no Quadro 4.2, o Servidor pode 
estar ocioso ou ocupado. Se ele estiver ocioso, ele recebe o pacote e o valor de eps é igual 
ao de cpf, ambos do segundo pacote, Figura 4.4.a. Se ele estiver ocupado, esta situação 
perdurará até o tempo sps do pacote anterior e, assim, eps é igual ao valor de sps do 
pacote anterior, Figura 4.4.b.
Desta forma, para o cálculo de eps[p], p ∈ [2,N], é necessário considerar duas 
alternativas, a saber:
1. cpf[p] > sps[p-1] então eps[p] = cpf[p], o Servidor está ocioso e o pacote é enviado 
a ele (Figura 4.4.a)
2. cpf[p] ≤ sps[p-1] então eps[p] = sps[p-1], o pacote aguarda na Fila e será enviado 
ao Servidor assim que ele finalizar o pacote anterior (Figura 4.4.b)
(a) (b)
Figura 4.4 Pacote chegando em Sistemas de Fila: a) Servidor ocioso quando cpf[p] > sps[p-1] 
e eps[p] = cpf[p]; b) Servidor ocupado quando cpf[p] ≤ sps[p-1] e eps[p] = sps[p-1].
Vale destacar que eps[p] ≥ cpf[p], ∀p ∈ [1,N].
Modelagem e Simulação Discreta 63
Exemplo 4.11 Representação gráfica dos valores de eps relacionadas aos eventos e pacotes 
dos Sistemas de Fila M/M/1
Na figura ao lado, estão representados três pacotes 
de um Sistema de Fila, Pi-2, Pi-1 e Pi. Cada pacote com 
seus três tempos dos eventos discretos: ∎ - chegada 
de pacote na Fila (cpf), ∎ - entrada de pacote no Ser-
vidor (eps) e ∎ - saída de pacote do Servidor (sps).
O valor de cpf de um pacote é calculado em função 
da taxa de chegada, já sps deste mesmo pacote de-
pende da taxa de serviço e eps.
O valor de epsi depende do valor de spsi-1, ou seja, 
para calcular epsi de um pacote é necessário o valor 
de sps do pacote que o antecede.
Ao chegar no Sistema de Fila, o pacote será encami-
nhado ao Servidor se ele estiver ocioso. Servidor oci-
oso indica que o pacote anterior foi processado e, 
neste caso, cpfi > spsi-1. Por outro lado, se o 
Servidor estiver ocupado então o pacote anterior ain-
da não foi processado e, neste caso, cpfi ≤ spsi-1.
Em termos matemáticos, o cálculo de eps de Pi-1 e Pi da figura acima é:
epsi-1 = spsi-2
epsi = cpfi
Em termos de modelagem matemática, o cálculo de eps de um pacote Pi qualquer é dado 
por:
se cpfi > spsi-1 então epsi = cpfi senão epsi = spsi-1, exceto o primeiro pacote para o 
qual eps0 = cpf0.
4.5 Cálculo de sps
Quando o segundo pacote sai do Servidor do Sistema de Fila no Quadro 4.2 o tempo 
transcorrido é igual ao valor de eps acrescido de ts, ambos do segundo pacote.
Generalizando, sps[p] = eps[p] + ts[p], p ∈ [1,N].
Modelagem e Simulação Discreta 64
4.6 Estatísticas do Modelo Conceitual de Sistemas de Fila
As variáveis aleatórias dos Sistemas de Fila M/M/1, suas equações ou seus valores 
esperados estão listadas no Quadro 4.3, adaptado de Chung (2004). Estas equações podem 
ser adaptadas para Sistemas de Filas A/B/c/K/m/Z.
Quadro 4.3 Valores das variáveis aleatórias dos Sistemas de Fila M/M/1 e seus valores 
médios, para p ∈ [1,N].
VA Descrição Estatística Equação
T tempo da simulação T=sps [N ] 4.1
tf[p] tempo de espera do pacote p na Fila t f [ p]=eps [ p]−cpf [ p] 4.2
ts[p] tempo de processamento do pacote p no Servidor t s[ p ]=sps [ p]−eps [ p ] 4.3
tsf[p]
tempo de processamento do pacote p no Sistema 
de Fila
t sf [ p ]=sps [ p]−cpf [ p] 4.4
E(nf) número médio de pacotes na Fila E(n f )=
1
N∑ n f [ p] 4.5
E(ns) número médio de pacotes no Servidor E(ns)=
1
N∑ ns [ p] 4.6
E(nsf) número médio de pacotes no Sistema de Fila E(nsf )=
1
N∑ nsf [ p] 4.7
E(tf) tempo médio de espera de pacotes na Fila E(t f )=
1
N∑ tf [ p ] 4.8
E(ts)
tempo médio de processamento de pacotes no 
Servidor
E(t s)=
1
N∑ t s[ p] 4.9
E(tsf)
tempo médio de processamento de pacotes no 
Sistema de Fila
E(t sf )=
1
N∑ t sf [ p] 4.10
U utilização do Servidor U= 1
T∑ t s[ p ] 4.11
p0 probabilidade de Servidor ocioso p0=1−U 4.12
Tempo da Simulação ou Duração da Simulação (T) é igual ao valor do último evento da 
simulação, que é de sps, Equação 4.1. Este valor correspondeao intervalo de tempo 
compreendido entre o início da simulação (cpf[0] = 0) e o seu final, o tempo que o último 
pacote sai do sistema, sps[N].
Os pacotes no Sistema de Fila incluem as que estiverem na Fila e também a que estiver 
no Servidor. Os pacotes na Fila excluem o que estiver no Servidor. Os pacotes no Servidor 
excluem os que estiverem na Fila.
Modelagem e Simulação Discreta 65
A simulação processa tempos e eventos, não são medidas operacionais18, são etapas 
intermediárias para estimar tf, tps, nf, ns e U, estatísticas úteis de Sistemas de Fila que 
permitem sua avaliação técnica e suas aplicações em engenharia.
4.7 Algoritmo para Calcular nf
Para calcular o valor de nf é necessário comparar os valores de cpf de um dado pacote 
com os de eps dos pacotes anteriores. Considerando o Servidor inicialmente ocioso, tem-se:
• o primeiro pacote 1 chega na Fila e vai para o Servidor, isto é nf[1] = 0
• o segundo pacote 2 chega na Fila e nf[2] = 0. Não é necessário verificar se o pacote 1 
está na Fila pois cpf[2] < eps[1].
• o pacote 3 chega na Fila, se cpf[3] ≥ eps[2] então o Servidor está ocioso e nf[3] = 0, 
caso contrário, cpf[3] < eps[2] e nf[3] = 1, o pacote 2 está na Fila. Não é necessário 
verificar se o pacote 1 está na Fila pois cpf[3] < eps[1].
• o pacote 4 chega na Fila, se cpf[4] ≥ eps[3] então o Servidor está ocioso e nf[4] = 0, 
caso contrário, cpf[4] < eps[3] e nf[4] = 1 mas é necessário verificar se o pacote 2 
está na Fila, ou seja, se cpf[4] ≥ eps[2] então o Servidor está ocioso e nf[4] = 1, caso 
contrário se cpf[4] < sps[2] e nf[4] = 2. Não é necessário verificar se o pacote 1 está 
na Fila pois cpf[4] < eps[1].
Generalizando, quando o p-ésimo pacote chega no Sistema de Fila, o tamanho da Fila 
nf[p] será igual à contagem dos casos em que cpf[p] < eps[i], i ∈ [1,p-1], Equação 4.13 e 
Figura 4.5.
n f [ p ]= ∑
i=p−1
1
1 ,cpf [ p]<eps[i] 4.13
A Figura 4.5 mostra 5 pacotes na reta do tempo na qual são destacados seus valores de 
cpf, eps e sps. Ao sair do Sistema de Fila, o pacote p-4 dá lugar ao processamento do 
pacote p-3 e, sequencialmente, chegam os pacotes p-2, p-1 e p. Como o valor de cpf[p] é 
menor do que eps[p-1] e eps[p-2], o valor de nf[p] é igual a 2.
18 Valores estimados por meio de estatísticas não são medidas operacionais. Medidas operacionais são valores medidos diretamente.
Modelagem e Simulação Discreta 66
Figura 4.5 Valor de cpf do pacote p em relação aos valores de eps dos pacotes anteriores, 
indicando 2 pacotes na Fila, ou seja, cpf[p] > eps[p-3].
Exemplo 4.12 Representação gráfica dos valores de nf relacionadas aos eventos e pacotes 
dos Sistemas de Fila M/M/1
Na figura do Exemplo 4.12 estão representados seis pacotes de um Sistema de Fila, Pi-5, Pi-4, 
Pi-3, Pi-2, Pi-1 e Pi. Cada pacote com seus três tempos dos eventos discretos: ∎ - tempo de che-
gada na Fila (cpf), ∎ - tempo de início de serviço (eps) e ∎ - tempo de fim de serviço (sps).
Um pacote, ao chegar no Sistema de Fila, pode ir para o Servidor ou esperar na Fila. Ele es-
pera sempre que cpfi ≤ epsi-1. Pode ter mais de um pacote na Fila e, para contá-los é neces-
sário comparar os valores de cpf com os valores de eps de todos os pacotes que o antece-
deram. A começar pelo seu antecessor. 
Modelagem e Simulação Discreta 67
Na figura acima, cpfi é menor do que epsi-1, epsi-2, epsi-3 e epsi-4, logo nf = 4, ou seja, quando 
o Pacote Pi entra na Fila ele encontra outros 4 (quatro) esperando para serem atendidos.
A função void Nf( int ), Programa 4.1, implementa a Equação 4.13 para calcular nf dos 
pacotes simulados.
Programa 4.1 Código em C++ para calcular nf de Sistemas de Fila M/M/1
void Nf( int p ){
 nf[p] = 0;
 for( int a = p-1; a > 0; a-- ){
 if( cpf[p] < eps[a] ) nf[p] += 1;
 eles break;
 }
}
4.8 Algoritmo para Calcular U
A Utilização é a razão entre o tempo de ocupação do Servidor e o tempo da simulação, 
Equação 4.14.
U= tempode ocupaçãpdo Servidor
tempoda simulação
4.14
O tempo que o Servidor fica ocupado durante a simulação igual a soma dos valores de ts 
durante todo processo e U pode ser estimada pela Equação 4.15. E p0 pode ser estimado a 
partir de U, Equação 4.16.
U=
∑
p=1
N
t s[ p ]
T
= 1
T∑p=1
N
t s [ p]
4.15
p0=1−U 4.16
O Programa 4.2 implementa a Equação 4.15 para calcular U e depois calcular p0.
Programa 4.2 Código em C++ para calcular U e p0 de Sistemas de Fila M/M/1
 T = sps[N-1];
 Sx = 0;
 for( int p = 0; p < N; p++ )
 Sx += sps[p]-eps[p];
Modelagem e Simulação Discreta 68
 U = Sx/T;
 p0 = 1-U;
4.9 Sumário do Modelo Conceitual de Sistemas de Filas
Os Quadro 4.4, Quadro 4.5 e Quadro 4.6 resumem o Modelo Conceitual dos Sistemas de 
Fila M/M/1.
Quadro 4.4 Modelo Conceitual de Sistemas de Fila M/M/1
Símbolo Descrição Valores
A Distribuição de tempo entre chegadas M – Processo de Poisson (Markoviano)
B Distribuição de tempo de serviço M – Processo de Poisson (Markoviano)
c Número de canais de serviços 1
K Capacidade do sistema ∞
m Tamanho da população ∞
Z Disciplina da fila
FIFO – primeiro que chega é o primeiro a 
ser atendido
Quadro 4.5 Entrada, parâmetros, eventos e saída do Modelo Computacional de Sistemas de 
Fila M/M/1
Entrada N, λ e μ
Parâmetros ic e ts, com ic = 1/λ e ts = 1/μ
Eventos cpf, eps, sps
Saída T, U, E[nf], E[tf], E[tsf], DP[nf], DP[tf], DP[tsf]
em que E é a esperança matemática (média aritmética) e DP é o desvio padrão19.
Quadro 4.6 Entrada, parâmetros, variáveis de estado e saída do Modelo Computacional de 
Sistemas de Fila M/M/1
p = 1
eps[1] = cpf[1] = ic[1]
sps[1] = eps[1] + ts[1]
2 ≤ p ≤ N cpf[p] = cpf[p-1] + ic[p]
cpf[p] > sps[p-1] então eps[p] = cpf[p] senão eps[p] = sps[p-1]
19 O desvio padrão da variável aleatória x é dada por DP( x)=√(E(x2)−[E (x)]2)
Modelagem e Simulação Discreta 69
sps[p] = eps[p] + ts[p]
No Exemplo 4.13 são calculados as estatísticas do Modelo Conceitual de Sistemas de 
Fila.
Exemplo 4.13 No Sistema de Fila M/M/1 simulado abaixo, com N = 10 pacotes, ic(s/p) = {3, 
5, 4, 3, 8, 5, 9, 8, 7, 6 } e ts(s/p) = { 12, 12, 10, 9, 2, 2, 1, 3, 2, 5 }:
p ic ts cpf eps sps tf ts tsf nf
1 3 12 3 3 15 0 12 12 0
2 5 12 8 15 27 7 12 19 0
3 4 10 12 27 37 15 10 25 1
4 3 9 15 37 46 22 9 31 1
5 8 2 23 46 48 23 2 25 2
6 5 2 28 48 50 20 2 22 2
7 9 1 37 50 51 13 1 14 2
8 8 3 45 51 54 6 3 9 3
9 7 2 52 54 56 2 2 4 0
10 6 5 58 58 63 0 5 5 0
∑ 108 58 166 11
Tem-se que T = sps[10] = 63 s.
Será calculado o valor de nf[8] a título de exemplo, neste caso nf[8] = 3:
• o pacote 8 chega na Fila no tempo cpf[8] = 45 s e nela permanece até o tempo igual 
a 51 s
• o pacote 7 chega na Fila no tempo cpf[7] = 37 s e entra no Servidor no tempo sps[7] 
= 50 s, ou seja, no tempo 45 s nf[8] = 1 pois cpf[8] < eps[7]
• o pacote 6 chega na Fila no tempo cpf[6] = 28 s e entra no Servidor no tempo eps[6] 
= 48 s, ou seja, no tempo 45 s nf[8] = 2 pois cpf[8] < eps[6]
• o pacote 5 chega na Fila no tempo cpf[5] = 23 s e entra no Servidor no tempo sps[5] 
= 46 s, ou seja, no tempo 45 s nf[8] = 3 pois cpf[8] < eps[5]
• o pacote 4 chega na Fila no tempo cpf[4] = 15 s e entra no Servidor no tempo sps[4] 
= 37 s, como cpf[8] ≥ eps[4] tem-se que nf[8] = 3 é não é necessário verificar os 
pacotes p < 4.
Modelagem e Simulação Discreta 70
Os outros valores de nf são calculados da mesma forma.
O tempo de espera na Fila é dada por tf[p] = eps[p]-cpf[p]. Os valores de tf estão 
calculados na tabela acima, logo E[tf] = ∑tf[p]/N = 108/10 = 10,8 s.
O tamanho médio da Fila é E[nf] = ∑nf[p]/N = 11/10 = 1,1 ou E[nf] = 2
A utilização U = ∑ts[p]/T = 58/63 = 0,921 ou U = 92,1%.
O cálculo de p0 = 1-U = 0,079 ou p0 = 7,9%.
O cálculo de E[ts] = ∑ts[p]/N = 58/10 = 5,8 s.
O tempo médio no sistema E[tsf] = ∑(sps[p]-cpf[p])/N = 166/10 = 16,6 s.
Modelagem e Simulação Discreta 71
4.10 Revisão
Parâmetros de entrada dos SF M/M/1: N, λ e μ
Valores iniciais (p = 0)20 e valores dos eventos dos sucessivos pacotes (1 ≤ p ≤ N):
PacoteSF
1
cpf1 = ic1
eps1 = cpf1
sps1 = eps1 + ts1
1 < p ≤ N
cpfp = icp + cpfp-1
epsp = cpfp > spsp-1 ? cpfp : spsp-1
spsp = epsp + tsp
Com:
n f [ p ]=∑
c=0
p−1
1 ,cpf [ p ]<sps [c ] ,
U= 1
T∑p=1
N
{sps [ p]−eps [ p ]} e 
T=sps [N ] .
Estatísticas:
E [tf ]= 1
N∑p=1
N
{eps[ p ]−cpf [ p ]} e DP [tf ]=√(E(tf 2)−[E(tf )]2) ,
E [tsf ]= 1
N∑p=1
N
{sps[ p ]−cpf [ p ]} e DP [tsf ]=√(E(tsf 2)−[E(tsf )]2) ,
E [nf ]= 1
N∑p=1
N
nf [ p] e DP [nf ]=√(E(nf 2)−[E(nf )]2) .
20 A sequência dos pacotes inciando em 0 visa o uso a linguagem C++.
Modelagem e Simulação Discreta 72
Figura 4.6 Hierarquia dos conceitos relacionados ao Modelos da Simulação Discreta.
4.11 Questões
1. Quais as diferenças entre os modelos de Sistemas de Fila M/M/1 e M/M/5.
2. Como um sistema CPU+Memória pode ser simulado pelo Sistemas de Fila M/M/1 se a 
memória não tem tamanho infinito?
3. Como estimar a performance de um computador em FLOPS?
4. Qual a implicação de Cov(nq,ns) = Cov(w,s) = 0 no Modelo Conceitual de SF?
4.12 Exercícios
1. Sabe-se que a HD Samsung 970 EVO de 1 TB, com 3.500 MB/s (leitura sequencial) e 
2.500 MB/s (escrita sequencial) está sendo usada para leitura e gravação de arquivos 
Modelagem e Simulação Discreta 73
de tamanhos médio iguais a 5 MB. Qual o tempo de serviço (ts) desta HD quando 
usada para leitura (tsleitura)? Qual o valor de tsgravação?
2. No Exemplo 4.9, o tempo de serviço para multiplicação de matrizes quadradas com a 
Nvidia GeForce RTX 3080 foi de 0,00420 s/p, para matrizes de ordem 5000 e 
algoritmos convencionais com O(n³). Qual é o ganho se usar o algoritmo de Strassen ≈ 
O(n2,807)?
3. Em abril de 2020, um projeto de computação alcançou 2,3 Eflop/s, combinando 
PlayStation 3, CPU e GPU. Qual o tempo de serviço deste projeto para multiplicação de 
matrizes quadradas de ordem 5000?
4. Considere a figura abaixo e calcule: a) o valor de nf do pacote 8; b) situe a coluna eps 
no pacote 10; e c) o tempo total da simulação até o pacote 12.
5. A tabela abaixo mostra evolução nas velocidades das DRAMs das tecnologias 
Samsung, calcule o tempo de serviço (ts) destas RAMs quando manipulam arquivos de 
tamanho médio igual a 5 MB.
Tecnologia RAM Velocidade (Gbps) ts(p/s)
Samsung LPDDR3 1,8
Samsung LPDDR4 3,7
Samsung LPDDR4X 4,2
Samsung LPDDR5 6,4
Samsung LPDDR5X 8,5
Modelagem e Simulação Discreta 74
5 MODELO COMPUTACIONAL DE SISTEMAS DE FILA
O Modelo Computacional de Sistemas de Fila M/M/1 está representado pela classe clSF 
do Quadro 5.1 e pelo Programa 5.1 escrito em C++. Esta classe encapsula os dados de 
entrada nos vetores ic e ts, as variáveis de estado nos vetores cpf, eps e sps, e o 
parâmetro N, para o número de simulações a realizar.
Quadro 5.1 Classe clSF do Modelo Computacional dos Sistemas de Fila M/M/1.
clSF
N, ic[N], ts[N], cpf[N], eps[N], sps[N]
clSF( int, vector<double>, vector<double> )
void Empacotar( int )
void Simular( void )
A classe clSF possui o parâmetro N, os dados de entrada ic e ts, e as variáveis de 
estado cpf, eps e sps, o construtor clSF e os métodos Empacotar e Simular, conforme a 
Quadro 5.1. Estas variáveis, exceto N, são vetores de tamanho N.
Programa 5.1 Código básico em C++ para simulação de Sistemas de Fila M/M/121
//---------------------------------------------------------------
#include <vector>
//---------------------------------------------------------------
using namespace std;
//---------------------------------------------------------------
class clSF{
 private:
 int N;
 vector<double> ic, ts, cpf, eps, sps;
 public:
 clSF ( int, vector<double>, vector<double> );
21 No Modelo Conceitual de Sistemas de Fila p ∊ [1,N] e no correspondente Modelo Computacional p ∊ [0,N-1], isto se deve ao uso das 
características da linguagem C++.
Modelagem e Simulação Discreta 75
 void Empacotar( int );
 void Simular ( void );
};
clSF::clSF( int N, vector<double> l, vector<double> m ){
 this->N = N;
 ic .resize(N);
 ts .resize(N);
 cpf.resize(N);
 eps.resize(N);
 sps.resize(N);
 for( int i = 0; i < N; i++ ){
 ic[i] = 1/l[i];
 ts[i] = 1/m[i];
 }
}
void clSF::Empacotar( int p ){
 cpf[p] = ic [p] + cpf[p-1];
 eps[p] = cpf[p] > sps[p-1] ? cpf[p] : sps[p-1];
 sps[p] = eps[p] + ts [p];
}
void clSF::Simular( void ){
 cpf[0] = ic [0];
 eps[0] = cpf[0];
 sps[0] = eps[0] + ts[0];
 for( int p = 1; p < N; p++ )
 Empacotar(p);
}
int main( void ){
 int N = 10;
 vector<double> l = { 8, 5, 12, 15, 8, 11, 9, 10, 7, 6 },
 m = { 11, 10, 9, 12, 9, 11, 14, 8, 9, 10 };
 clSF SF(N,l,m);
 SF.Simular();
 return 0;
}
Na função main são declaradas e atribuídos os valores de N, l e m. O construtor clSF 
recebe, como parâmetros, a variável N e os vetores l e m; configura os vetores ic, ts, cpf, 
eps e sps, e calcular os valores de ic e ts a partir de l e m, respectivamente. Em seguida 
executa o método Simular que atribui os valores de cpf, eps e sps do primeiro pacote (p = 
0) e, por fim, executa o método Empacotar para p = 1, 2, 3, …, N-1, calculando os valores 
de cpf, eps e sps de cada pacote, evento a evento.
Modelagem e Simulação Discreta 76
5.1 Técnica para Gerar ic e ts
Até agora foram utilizando os valores medidos de ic e de ts nos modelos mas, para 
simular um número de pacotes maior do que o número de dados observados, é necessário 
gerar variáveis aleatórias:
• ic a partir de λ, ic = 1/λ22
• ts a partir de μ, ts = 1/μ23
A geração de variáveis aleatórias é feita a partir dos valores médios de dados medidos 
ou estimados. Para isso será usada uma função distribuição de probabilidade exponencial 
para gerar variáveis aleatórias a partir dos valores médios24. As técnicas para gerar variáveis 
aleatórias (GVA) a partir de geradores de números aleatórios (GNA) serão estudadas no 
Capítulo 11.
A função double X(double p) do Programa 5.2 gera variáveis aleatórias da função 
distribuição de probabilidade exponencial. Ela requer o parâmetro p (valor médio dos dados 
observados ou estimados), neste caso, os valores de λ ou de μ é atribuído a p. Quando a 
função X é chamada com o argumento λ, ela gera variáveis aleatórias de intervalo entre 
chegadas. Por outro lado, quando a função X é chamada com o argumento μ, ela gera 
variáveis aleatórias de tempo de serviço, como mostrado no diagrama de estado das taxas 
de transição na Figura 5.1 e Equação 5.1 Equação 5.2.
Figura 5.1 Diagrama de transição de estado de Sistemas de Fila M/M/1 destacando os valores 
das taxas de transição X(λ) e X(μ).
ic=X (λ) 5.1
ts=X (μ) 5.2
Programa 5.2 Função C++ para gerar variáveis aleatórias com distribuição de 
probabilidade exponencial
double X( double p ){
22 Note que a unidade de medida de λ é p/s (pacote/segundo) e a unidade de medida de ic é s/p (segundo/pacote).
23 Note que a unidade de medida de μ é p/s e a unidade de medida de ts é s/p.
24 Pode-se usar qualquer função distribuição de probabilidade para gerar variáveis aleatórias, o uso da fdp exponencial está em conformi-
dade com os resultados do Modelo Analítico da Teria de Filas (M/M/1).
Modelagem e Simulação Discreta 77
 double u = (rand()+1.0)/(RAND_MAX+2.0); // u in (0,1)
 return -log(u)/p;
}
Os termos srand(), rand(), RAND_MAX fazem parte da biblioteca de números aleatórios 
das linguagens C e C++ e serão estudados no Capítulo 10.
Os valores ic e ts gerados pela função X variam para cada simulação realizada pois são 
obtidas a partir de u, que é gerado aleatoriamente. Desta forma são gerados valores de ic e 
de ts em torno de cada média fornecida, como mostra a Figura 5.1.
Podem ser usadas outras funções além da exponencial, basta incluir a função de 
interesse, que será estudado mais adiante.
No Modelo Computacional temos ainda que:
• λ é o número de pacotes que chegam na Fila por unidade de tempo – taxa de chegada 
- dado medidoou estimado
• μ é o número de pacotes processadas pelo Servidor por unidade de tempo – taxa de 
serviço - dado medido ou estimado
• ic é o intervalo médio entre chegadas de pacotes na Fila
• ts é o tempo médio de serviço de pacotes do Servidor
• l é usado em lugar de λ, sendo ic = X(l)
• m é usado em lugar de μ, sendo ts = X(m)
5.2 Software SF.MM1.cpp
O código completo em C++ para simulação de Sistemas de Fila M/M/1, denominado 
SF.MM1.cpp, pode ser visto no Programa 15.1 do Capítulo 15.2.
O programa SF.MM1.cpp tem mudanças na sua estrutura e organização interna quando 
comparado com o do Programa 5.1, a saber:
• os valores de l e m são valores médios, não são vetores
• os dados de entrada são N, l e m 
• ic e ts são calculados a partir de l e m, respectivamente, utilizando a função X
• tabela com os valores p, ic, cpf, eps, sps e nf
• o vetor E para os valores médios de tf, ts e tsf
• o vetor DP para os valores do desvio padrão de tf, ts e tsf
• as variáveis T e U
Modelagem e Simulação Discreta 78
No programa SF.MM1.cpp, as variáveis de estado são calculados pelos métodos X, 
Iniciar, Empacotar, Simular e Nf. Os indicadores são calculados pelo método Estatistica. 
O relatório final é feito pelos métodos Tabela, Resumo e Legenda. Estes métodos são 
descritos abaixo:
• X calcula variáveis aleatórias ic e ts utilizando a fdp exponencial
• Iniciar atribui valores para ic, ts, cpf, eps, sps e nf do primeiro pacote
• Empacotar calcula os valores de ic, ts, cpf, eps e sps dos demais pacotes 
• Simular simula cada pacote, do segundo ao último, sequencialmente 
• Nf calcula a variável de estado nf de cada pacote
• Estatistica calcula as médias e desvio padrão de nf, ic, ts, cpf, eps, sps, tf, tps e tsf
• Tabela relata os valores de ic, ts, cpf, eps, sps e nf de cada pacote no formato html
• Resumo calcula os valores de T e U e faz um resumo das médias e desvios padrões no 
formato html
• Legenda cria legenda no formato html
As variáveis utilizadas no software SF.MM1.cpp estão sumarizadas no Quadro 5.2.
Quadro 5.2 Variáveis utilizadas no software SF.MM1.cpp
Nome Descrição
Dados de Entrada
N número de pacotes da simulação
l taxa de chegada na Fila (p/s)
m taxa de serviço do Servidor (p/s)
Eventos
cpf tempo de chegada de pacote na Fila (s)
eps tempo de chegada de pacote no Servidor (s)
sps tempo de saída de pacote do Servidor (s)
Estatísticas
nf número de pacotes da Fila
tf tempo de espera na Fila (s)
ts tempo de permanência no Servidor (s)
tsf tempo de permanência no Sistema de Fila (s)
T duração da simulação (s)
U utilização do Servidor
Modelagem e Simulação Discreta 79
Indicadores
E[X] E[nf], E[tf], E[ts], E[tsf]
DP[X] DP[nf], DP[tf], DP[ts], DP[tsf]
O Exemplo 5.1 simula 10 eventos de um SF com l = 6 p/s e m = 5,2 p/s, usando o 
Programa 15.1.
Exemplo 5.1 Foi executado o Programa 15.1, com entradas N = 10, l = 6 p/s e m = 5,2 p/s, 
com os resultados apresentados abaixo:
p ic ts cpf eps sps
0 0,16 0,76 0,16 0,16 0,92
1 0,10 0,10 0,26 0,92 1,02
2 0,12 0,04 0,38 1,02 1,06
3 0,02 0,05 0,40 1,06 1,11
4 0,40 0,03 0,80 1,11 1,14
5 0,01 0,06 0,80 1,14 1,21
6 0,76 0,23 1,56 1,56 1,79
7 0,07 0,02 1,63 1,79 1,81
8 0,03 0,07 1,66 1,81 1,88
9 0,02 0,11 1,68 1,88 1,99
Resumo
N 10
T 1,991
E[ic] 0,168
DP[ic] 0,057
E[ts] 0,148
DP[ts] 0,050
E[nf] 2,100
DP[nf] 2,767
E[tf] 0,313
DP[tf] 0,067
Modelagem e Simulação Discreta 80
E[tsf] 0,461
DP[tsf] 0,058
U 0,743
Valores de ic gerados
A execução de ic = X(l) = 0,167 s/p) gera os N = 10 valores de ic a partir de X(l) conforme 
listados na tabela acima. A figura abaixo é o gráfico de ic versus p. A linha ic (em cor preta) 
é constante e as colunas de ic (em cor verde) varia ora acima ora abaixo do valor de λ, o 
que denota a aleatoriedade da simulação.
Valores de ts gerados
A execução de ts = X(m) = 0,191 s/p ) gera os N = 10 valores de ts a partir de X(m) 
conforme listados na tabela acima. O gráfico de ts versus p estão no gráfico abaixo. A linha 
ts (em cor preta) é constante e a coluna de ts (em cor laranja) varia em torno de μ e denota 
a aleatoriedade da simulação.
Os valores de ic e ts das figuras acima variam para cada simulação que for realizada pois 
são obtidas a partir de u, que é gerado aleatoriamente. Desta forma são gerados valores de 
ic e de ts em torno da média p fornecida.
Valores de cpf, eps e sps simulados
Os valores de cpf (verde), eps (laranja) e sps (azul) versus p estão no gráfico abaixo. 
Modelagem e Simulação Discreta 81
Quando a coluna de cpf tem o mesmo valor que a de eps significa que o pacote não 
esperou na Fila, chegou e foi direto para o Servidor. Quanto maior a diferença entre cpf e 
eps maior será o tempo de espera na Fila. Quanto maior a diferença entre as colunas sps e 
eps maior será o tempo de serviço.
Valores de tf, ts e tsf simulados
Os valores de tf (verde), ts (laranja) e tsf (azul) versus p estão no gráfico abaixo. O pacote p 
= 0 tem tf = 0 porque não espera na Fila, ao chegar, vai direto para o Servidor. O pacote e 
= 6 também não espera na Fila. Quanto maiores os valores das colunas maiores serão a 
duração dos eventos. 
Valores de nf simulados
Os valores de nf (cinza) versus p está no gráfico abaixo. Para p = 0 e p = 6 não tem pacote 
na Fila. Quanto maior o valor das colunas, maior será o tamanho da Fila.
Modelagem e Simulação Discreta 82
O Exemplo 5.2 avaliar a capacidade do servidor HPE ProLiant ML110 E5-2640v4 para 
processar as mensagens do Instagram.
Exemplo 5.2 Utilize o SF.MM1.cpp (Programa 15.1), para avaliar a capacidade do servidor 
HPE ProLiant ML110 E5-2640v4, com vazão de 8,0 GT/s25, em processar as mensagens do 
Instagram.
No Exemplo 4.5 foi estimado o tamanho do pacote do Instagram como sendo 3100 B e no 
Quadro 4.4 está sua demanda que é λ = 5787 p/s.
Tamanho do pacote = 3100 B
Taxa de serviço:
μ=8GT / s=8
GB
s
pacote
pacote
= 8GB
pacote
pacote
s
= 8GB
3100B
pps=8×10243B
3100 B
=2770946 pps=2,8×106 pps
Configuração do SF.MM1.cpp: N = 5000, l = 5787.0, m = 2770946.0
Resultados obtidos:
l = 5787
m = 2770946
N = 5000
T = 0,876
E(tsf) = 0,000000361
E(nf ) = 0
DP(tsf) = 0,000000365
DP(nf) = 0,0489
U = 0,002050
Conclusão: a simulação resultou em U ≈ 0 e valores médios de tsf ≈ 0 e de nf = 0; sendo 
assim, o servidor HPE ProLiant ML110 E5-2640v4 é recomendado para o processamento de 
mensagens do Instagram, embora apresente grande ociosidade.
Recomendação: se este projeto for implantado, recomenda-se fortemente monitorar e 
avaliar a solução proposta para julgar a qualidade da simulação e fazer os ajustes que se 
fizerem necessários.
O Exemplo 5.3 avaliar a capacidade do servidor HPE ProLiant ML110 E5-2640v4 para 
processar as mensagens do Whatsapp.
Exemplo 5.3 Sabendo que o pacote do Whatsapp é igual a 2,68 MB26 e que λ = 483333,3 
p/s27, utilize o SF.MM1.cpp para avaliar a capacidade do servidor HPE ProLiant ML110 E5-
2640v4, com vazão de 8,0 GT/s, em processar as mensagens do Whatsapp.
Tamanho do pacote = 2,68 MB
Taxa de serviço:
25 Fonte: https://support.hpe.com/hpesc/public/docDisplay?docId=emr_na-c04617738#N10057
26 Fonte: https://melhorplano.net/blog/whatsapp-internet/
27 Fonte: https://macmagazine.com.br/post/2018/11/14/cerca-de-29-milhoes-de-mensagens-sao-enviadas-por-minuto-no-whatsapp/
Modelagem e Simulação Discreta 83
Exemplo 5.3 Sabendo que o pacote do Whatsapp é igual a 2,68 MB e que λ = 483333,3 p/s, 
utilize o SF.MM1.cpp para avaliar a capacidade do servidor HPE ProLiant ML110 E5-2640v4, 
com vazão de 8,0 GT/s, em processar as mensagens do Whatsapp.
μ=8GT / s=8
GB
s
pacote
pacote
= 8GB
pacote
pacote
s
= 8GB
2,68MB
pps=8×1024 MB
2,68 MB
=3056,7 pps
Configuração do SF.MM1.cpp: N = 5000, l = 483333.3, m = 3056.7
Resultados obtidos:
l = 483333,3
m = 3056,7
N = 5000
T = 1,6270
E(tsf) = 0,8005
E(nf) = 2490
DP(tsf) = 0,4637
DP(nf) = 1437,4
U = 1,0000
Conclusão: a simulação resultou em U = 100%; sendo assim, o servidor HPEProLiant 
ML110 E5-2640v4 não é recomendado para o processamento de mensagens do Whatsapp.
Modelagem e Simulação Discreta 84
5.3 Revisão
Modelagem e Simulação Discreta 85
5.4 Questões
1. Porque p0 não aparece no resultado do Exemplo 5.1
2. Interprete os gráficos do Exemplo 5.1.
Modelagem e Simulação Discreta 86
p ic ts cpf eps sps nf tf tes te
0 0 0 0 0 0 0 0 0 0
1 1 4 1 1 5 0 0 4 4
2 1 2 2 5 7 1 3 2 5
3 2 5 4 7 12 2 3 5 8
4 1 2 5 12 14 2 7 2 9
5 1 3 6 14 17 3 8 3 11
6 1 4 7 17 21 3 10 4 14
7 2 2 9 21 23 4 12 2 14
8 3 1 12 23 24 4 11 1 12
9 2 2 14 24 26 4 10 2 12
5.5 Exercícios
1. Compare os indicadores obtidos por simulação com os do correspondente modelo 
analítico sabendo que λ = { 8 5 12 15 8 11 9 10 7 6 } e μ = { 11 10 9 12 9 11 14 8 9 
10 }. 
2. Pacotes que chegam em um Sistema de Fila M/M/1 com intervalo entre chegadas λ = { 
8 5 12 15 8 11 9 10 7 6 } e tempos de serviço μ = { 11 10 9 12 9 11 14 8 9 10 }, 
simule 5 vezes e calcule a média e a variância dos nos indicadores estimados (tf, tps e 
tsf)? Compare os indicadores obtidos por simulação (a) com os do correspondente 
modelo analítico (b), utilize o erro relativo percentual28, erp(%) = 100 (a-b)/b, para 
comparação.
3. Repita o exercício 2 para as séries de dados: λ = { 5,7 7,8 8,0 7,7 5,0 6,1 8,0 2,6 3,2 
3,4 7,7 7,6 7,2 3,2 7,6 3,3 6,8 6,8 } e μ = { 4,4 5,2 4,5 5,5 4,1 6,9 7,9 5,1 3,7 5,3 3,3 
4,1 5,7 5,6 4,4 7,1 4,1 7,2 }
4. Repita o exercício 2 para as séries de dados: λ = { 22 22 31 13 12 29 32 19 17 20 13 
23 13 20 27 18 22 1 20 14 19 6 22 17 27 24 } e μ = { 33 44 13 19 28 24 35 36 34 27 
14 30 23 17 23 5 20 39 37 35 23 34 22 28 42 27 }
28Dadas duas medidas a e b, o erro relativo percentual (erp) de a em relação a erp (%) = 100 (a-b)/b, usado para indicar a percentagem 
que a > b (erp > 0) ou que a < b (erp < 0) ou que a = b (erp=0). 
Modelagem e Simulação Discreta 87
5. Repita o exercício 2 para as séries de dados: λ = { 24 28 20 24 28 15 24 24 23 16 28 
28 32 23 22 21 19 27 28 23 36 24 } e μ = { 19 14 18 9 29 9 25 17 30 19 12 15 9 22 
22 31 19 12 12 16 30 2 }
6. Segundo HTTP Archive (site que rastreia o desempenho da web e suas tecnologias), o 
tamanho médio de uma página web em 03/2020 foi de 2 MB. A taxa de transferência 
de 2 MB com tecnologia 4G é de menos de 1 s. Analise o Panorama de tráfego da RNP 
– https://www.rnp.br/sistema-rnp/ferramentas/panorama-de-trafego – e estime a 
quantidade máxima de usuário, com tecnologia 4G, que pode usar a web com estas 
taxas.
7. Altere o software SF.MM1.cpp de modo que sua disciplina da fila seja “Menor Tarefa 
Primeiro” (SJF – shortest job first) – o pacote que tem o menor tempo de serviço será 
encaminhado ao Servidor. Ou seja, implemente e software SF.M/M/1/∞/∞/SIF.cpp.
8. Considere a comparação entre processadores para desktop Intel® Core™ da 13ª 
Geração do quadro abaixo e calcule:
a) o tempo de serviço de uma DDR5 para pacotes de 2 MB.
b) o tempo de serviço de um núcleo para pacotes de 2 MB. 
Recurso29 i9 i7 i5
Núcleos dos processadores
(P-cores + E-cores)
24
(8P+16E)
16
(8P+8E)
14
(6P+8E)
Total de threads do processador 32 24 20
Tamanho do Cache Inteligente L3 [MB] 36 MB 30 MB 24 MB
Tamanho total do Cache L2 [MB] 32 MB 24 MB 20 MB
Velocidade máxima da memória [MT/s] DDR5-5600 DDR5-5600 DDR5-5600
Nº de canais de memória 2 2 2
Vias PCIe 5.0 da CPU 32 GT/s, 16 vias 32 GT/s, 16 vias 32 GT/s, 16 vias
9. Compare os resultados dos softwares SF.MM1.cpp e SF.M/M/1/∞/∞/SIF.cpp.
29 https://www.intel.com.br/content/www/br/pt/products/docs/processors/core/13th-gen-core-desktop-brief.html
Modelagem e Simulação Discreta 88
6 VERIFICAÇÃO E VALIDAÇÃO DE MODELOS
Deve-se garantir a implementação correta de modelos computacionais para fins de 
simulação para que eles possam representar os sistemas do mundo real. A avaliação da 
qualidade da simulação é medida pela proximidade dos resultados de um modelo 
comparados com dados de sistemas do mundo real.
Figura 6.1 Da simulação de sistemas aos seus resultados.
Uma vez que uma série de suposições sobre o comportamento de sistemas do mundo 
real são feitas no desenvolvimento de modelos, há duas etapas para medir sua qualidade:
• Verificação – verifica a correção da implementação, se o modelo computacional 
implementa as suposições corretamente
• Validação – valida a representatividade dos pressupostos no modelo conceitual, se as 
premissas são razoáveis
Como pode ser visto na Figura 6.2, validação e verificação são conceitos diferentes. A 
verificação também pode ser chamada de depuração, ou seja, avalia se o modelo 
computacional realiza o que se espera do modelo conceitual. A validação permite ajustar o 
comportamento do modelo conceitual ao sistema do mundo real.
Figura 6.2 Relação entre os conceitos de validação e verificação, o mundo real e os modelos 
conceitual e computacional.
Modelagem e Simulação Discreta 89
Em relação à implementação das hipóteses e ao realismo dos pressupostos, um modelo 
pode estar em qualquer uma das quatro categorias possíveis apresentadas no Quadro 6.1.
Quadro 6.1 Categorias dos modelos relativa à implementação das hipóteses e realismo dos 
pressupostos.
Pressupostos
Implementação das Hipóteses
correta incorreta
realistas validado e verificado validado e não verificado
não realistas não validado e verificado não validado e não verificado
Apenas os modelos válidos e verificados podem ser capazes de representar sistemas do 
mundo real, os demais não são confiáveis.
6.1 Técnicas de Validação de Modelo
Validação consiste em assegurar que os pressupostos utilizados, as simplificações 
adotadas, o nível de detalhamento e o escopo do modelo conceitual estão de acordo e 
representam adequadamente o sistema a ser simulado e que, se implementado 
corretamente, o modelo computacional tenha comportamento e produza resultados 
semelhantes àquelas observados nos sistemas do mundo real.
As técnicas de validação dependem dos pressupostos e, portanto, do sistema que está 
sendo modelado. Assim, ao contrário de técnicas de verificação que são de aplicação geral, 
as técnicas de validação utilizadas na simulação de um modelo podem não se aplicar a outro.
Validação do modelo consiste em validar os três aspectos-chave do modelo:
• Suposições
• Valores dos parâmetros de entrada e distribuições de probabilidade
• Valores de saída e conclusões
Cada um destes três aspectos pode ser submetido a um teste de validade, comparando-
a com o obtido a partir das seguintes possíveis três fontes:
• Discernimento do Especialista – é a forma mais prática e comum para validar um 
modelo. Os pressupostos do modelo devem ser validados por especialistas. Os valores 
de entrada e distribuição de probabilidade devem ser discutidos e validados durante o 
desenvolvimento do modelo. A saída deve ser validada, logo que existir um executável 
do modelo
Modelagem e Simulação Discreta 90
• Medidas Sistema – comparação com sistemas do mundo real é a maneira mais 
confiável e preferida para validar um modelo de simulação. Suposições, valores de 
entrada, valores de saída, cargas de trabalho, configurações e comportamento do 
sistema devem ser comparados com os observados no mundo real utilizando técnicas 
estatísticas
• Resultados Teóricos – em alguns casos, é possível resolver analiticamente o modelo 
do sistema sob hipóteses simplificadoras. Também pode ser possível determinar 
analiticamente as distribuições de probabilidade de entrada. Nesses casos, a 
semelhança de resultados teóricos e os resultados da simulação é usada para validar o 
modelo de simulação
Combinando os aspectos-chave do modelo com as fontes dos testes de validade, obtém-
se a nove testes de validação possíveis. Claro, pode não ser viável a utilização de algumas 
dessas possibilidades. Por exemplo, medições reais do sistema podem estar disponíveis ou 
não, resultadosteóricos podem estar disponíveis ou não. O analista deve, pelo menos, 
validar o modelo para configurações simples.
6.2 Técnicas de Verificação de Modelos
A verificação consiste em assegurar que o modelo computacional implementa 
corretamente o modelo conceitual. A verificação de modelos de simulação é equivalente a 
retirar os bugs de programas (debugging). Ela também busca identificar elementos que 
possam ocasionar o mal funcionamento do modelo computacional.
A qualidade dos dados de entrada também é de extrema importância. Estes dados 
podem ser utilizados com três finalidades básicas: construção do modelo conceitual, 
validação de resultados e experimentação. Desta forma, se os dados de entrada do modelo 
estão incorretos, não há como melhorar o modelo ou mesmo gerar resultados corretos.
As técnicas para a Verificação de Modelos podem ser vistas no Quadro 6.2.
Quadro 6.2 Técnicas para a Verificação de Modelos
• Modelos Determinísticos – a técnica consiste em eliminar a aleatoriedade, 
especificando distribuições constantes (determinísticas) para que se possa facilmente 
determinar variáveis de saída e, assim, depurar o software
• Executar Casos Simplificados – o modelo pode ser executado com casos simples 
como, por exemplo, apenas um pacote. Estes casos podem ser facilmente analisados 
e os resultados da simulação podem ser comparados com os modelos analíticos. É 
claro, um modelo que funciona para casos simples não é garantido que funcione para 
Modelagem e Simulação Discreta 91
os casos mais complexos. Portanto, os testes devem ser tão complexos quanto 
puderem ser analisados sem simulação
• Rastreio (Trace) – as saídas de rastreio são úteis na depuração de modelos pois são 
dados medidos, refletem o comportamento do sistema
• Gráficos Online – simulações levam muito tempo para serem executadas. Gráficos 
on-line podem exibir resultados para ajudar a manter o usuário informado sobre o 
estado da simulação. Eles também são úteis para tornar a simulação mais 
interessante e vender seus resultados para terceiros
• Teste de Continuidade – consistem em executar a simulação várias vezes para 
valores ligeiramente diferentes dos parâmetros de entrada. Para qualquer parâmetro, 
uma pequena mudança na entrada deve geralmente produzir apenas uma ligeira 
alteração na saída. Toda mudança repentina na saída deve ser investigada. Muitas 
vezes, eles são devidos a erros de modelagem
• Testes de Degenerescência – consistem em verificar se o modelo funciona para 
valores extremos (menores ou maiores permitidos) do sistema, configuração, ou 
parâmetros de carga de trabalho. Por exemplo, modelo de estação de trabalho com 
multiprocessador e vários discos deve ser capaz de simular também uma única CPU 
sem disco (diskless) mesmo que estas configurações não sejam válidas para o 
sistema
• Independência da Semente – as sementes utilizadas na geração de números 
aleatórios não deve afetar o resultado final. Assim, o modelo deverá produzir 
resultados semelhantes para diferentes valores de sementes, o que deve ser 
verificado
No Exemplo 6.1 estão exemplos de códigos da função que gera variáveis aleatórias com 
distribuição exponenciais e de função que gera valores fixos com distribuição exponenciais 
(determinística).
Exemplo 6.1 Geração de variáveis aleatórias exponenciais e determinísticas para simulação
A função abaixo gera variáveis aleatórias com distribuição exponenciais
double clSF::X( double p ){
 double u = (rand()+1.0)/(RAND_MAX+2.0);
 return -log(u)/p;
}
A função abaixo gera valores fixos com distribuição exponenciais (determinística)
double clSF::X( double p ){
 double u = 0.5; // ou outra constante
 return -log(u)/p;
Modelagem e Simulação Discreta 92
}
No Exemplo 6.2 estão exemplos de construtor da classe configura o gerador de números 
aleatórios com tempo do sistema e construtor da classe configura o gerador de números 
aleatórios com valor fixo.
Exemplo 6.2 Sementes variáveis e sementes fixas
A função abaixo inicia o gerador com sementes variáveis
clSF::clSF(){
 srand(time(nullptr));
}
A função abaixo inicia o gerador com uma semente fixa, serve para avaliar a independência 
da semente
 clSF::clSF(){
 srand(123456890);
}
6.3 Revisão
6.4 Questões
1. Proponha uma metodologia para validar o Modelo Conceitual de Sistemas de Filas 
M/M/1 apresentado anteriormente.
Modelagem e Simulação Discreta 93
2. O que significa "modele simples - pense complicado" no contexto da Modelagem e 
Simulação.
3. O que significa "o incremento da qualidade obedece a Lei dos Rendimentos 
Decrescentes, já os custos crescem exponencialmente" no contexto da Modelagem e 
Simulação.
6.5 Exercícios
1. Considere λ = { 5,7 7,8 8,0 7,7 5,0 6,1 8,0 2,6 3,2 3,4 7,7 7,6 7,2 3,2 7,6 3,3 6,8 6,8 } 
e μ = { 4,4 5,2 4,5 5,5 4,1 6,9 7,9 5,1 3,7 5,3 3,3 4,1 5,7 5,6 4,4 7,1 4,1 7,2 } e avalie 
o Modelo Conceitual de Sistemas de Filas M/M/1 apresentado anteriormente usando: a) 
teste de continuidade, b) testes de degenerescência, c) teste de consistência, e d) 
teste da independência da semente.
Modelagem e Simulação Discreta 94
7 ANÁLISE DE RESULTADOS SIMULADOS
A simulação de modelos matemáticos de sistemas computacionais pode apresentar 
erros de diferentes fontes. A começar pelos próprios modelos que, por construção, são 
representações simplificadas de sistemas do mundo real; os erros inerentes ao processo da 
amostragem também estão presentes nos parâmetros de suas entradas, que também são 
fontes de erros. Ao simular estes modelos matemáticos em computadores, fazendo uso de 
números aleatórios, são introduzidas variabilidade estatística nos resultados. Em resumo, não 
há como controlar estas fontes de erros. Vale ressaltar que, apesar de tudo isso, ainda assim 
a simulação dá bons resultados e pode ser utilizada de modo confiável.
Neste capítulo serão apresentadas técnicas estatísticas que permitem avaliar resultados 
de simulações, sua qualidade, pertinência e assegurar seu uso. A análise de saída é um dos 
aspectos mais importantes de qualquer estudo de simulação adequado e completo. Como os 
processos de entrada da simulação são variáveis aleatórias, notadamente tempos entre 
chegadas e tempos de serviços, deve-se considerar a saída da simulação também como 
variável aleatória. Assim, simulações resultam apenas em estimativas de medidas de 
desempenho do sistema. Esses estimadores são, eles mesmos, variáveis aleatórias sujeitos 
ao erro amostral, o qual deve ser levado em conta para se fazer inferências válidas em 
relação aos valores dos resultados simulados.
Na maioria dos sistemas simulados, os valores iniciais das suas variáveis de estado e de 
saída podem apresentar grandes variações e mesmo oscilações, esta parte inicial é chamada 
de estado transiente, após o que o sistema pode atingir um estado estável, denominado 
estado estacionário, Figura 7.1. Há simulações cujo foco é o estado transiente e há outras 
cujo interesse é o estado estacionário, há ainda aquelas que buscam estudar ambos estados. 
Há também sistemas simulados que apresentam oscilações cíclicas, periódicas ou não. 
Sistemas de comportamento caótico30 ou divergente são de pouco interesse prático em 
sistemas computacionais.
30 Séries caóticas e séries aleatórias são parecidas no sentido de que não possuem regularidade, a característica que identifica o 
comportamento caótico é a sua dependência das condições iniciais, condições iniciais indistinguíveis podem gerar comportamentos 
imprevisíveis, o que inviabiliza a repetibilidade bem como a previsibilidade do comportamento do sistema
Modelagem e Simulação Discreta 95
Figura 7.1 Indicação dos estados transiente e estacionário de uma simulação típica.
Pode-se identificar dois tipos de simulação em relação à análise da saída: simulações 
terminaise de estado estacionário.
• Simulações terminais ou transientes – neste caso estuda-se o comportamento de 
curto prazo do sistema, como a simulação de um sistema que é executado em um 
horário específico a cada dia, como backup. Neste caso, a natureza do problema define 
explicitamente o número de pacotes a serem simulados.
• Simulações de estado estacionário – neste caso estuda-se o comportamento a 
longo prazo do sistema, como simular um serviço em nuvem que fica disponível 
continuamente, para a qual há interesse em alguma medida de desempenho a longo 
prazo. Presumivelmente, esse comportamento de estado estacionário é independente 
das condições iniciais da simulação.
As técnicas para analisar saídas de simulações terminais se baseiam no método de 
replicações independentes, discutido abaixo.
Problemas adicionais surgem para simulações de estado estacionário e as seguintes 
etapas na execução da simulação também devem consideradas:
• remoção de transientes – quantos pacotes iniciais devem ser descartadas para 
garantir que a simulação chegue a um estado de equilíbrio?
• critério de parada – quantos pacotes serão necessários para executar a simulação?
7.1 Remoção de Transientes
Modelagem e Simulação Discreta 96
Antes que uma simulação possa ser executada, devem-se definir valores iniciais para 
suas variáveis de estado. Como, em princípio, os valores iniciais apropriados destas variáveis 
de estado não são conhecidos, esses valores devem ser escolhidos arbitrariamente, 
utilizando-se de alguns critérios como, por exemplo, iniciar uma Fila vazia e seu Servidor 
ocioso por questões de conveniência. As condições iniciais de uma simulação podem ter uma 
influência significativa nos seus resultados, podendo levar a erros na análise da saída de 
estado estacionário.
Na maioria das simulações, apenas o desempenho em estado estacionário, isto é, o 
desempenho depois que o sistema tenha atingido um estado estável, é de interesse. Nesses 
casos, os resultados da parte inicial da simulação não devem ser incluídos nos cálculos finais. 
Essa parte inicial é também chamada de estado transiente, Figura 7.1.
O problema de identificar o fim do regime transiente é chamado de remoção de 
transientes e sua principal dificuldade é que não é possível definir exatamente o que 
constitui o estado transiente e quando ele termina. Todos os métodos para a remoção de 
transientes são, portanto, heurísticas e são baseados no pressuposto de que a variabilidade 
durante o estado de equilíbrio é menor do que durante o estado transiente, o que geralmente 
é verdade. Os métodos mais importante são:
Quadro 7.1 Principias métodos para a remoção de transientes
Execuções Longas – é um método simples, usa execuções muito longas, ou seja, 
execuções que são suficientemente longas para garantir que a presença de condições 
iniciais não afetará o resultado. A desvantagens neste método é que é difícil garantir que o 
comprimento da execução escolhido é suficiente.
Truncamento – neste método, a variabilidade é medida em termos de alcance mínimo e 
máximo dos valores das simulações. Se uma trajetória mostrando valores sucessivos em 
um gráfico, pode ser visto quando a simulação estabilizar e entrar na fase estacionária
Replicações Independentes – este método requer a execução de várias simulações 
muito longas. Cada simulação é chamada de replicação. A média das amostras finais 
retiradas de cada replicação é chamada de médias amostrais das replicações.
Média de Lotes – este método requer a execução de uma única simulação muito longa e 
dividi-la em várias partes, cada parte é chamada de lote. A média de observações em cada 
lote é chamada média de lote. Este método permite estudar a variação destas médias em 
função do tamanho dos lotes e do seus número.
Antes de tratar da remoção de transientes, será estudado a estimação por intervalos de 
confiança, utilizados por estes os métodos.
Modelagem e Simulação Discreta 97
7.1.1 Estimação por Intervalos de Confiança
Um Intervalos de Confiança (IC) indica a confiabilidade de um parâmetro de uma 
população. O IC está associada à incerteza que se tem a respeito da estimativa deste 
parâmetro.
Geralmente pode-se especificar a incerteza definindo-se um intervalo dentro do qual se 
espera que o valor esteja com uma certa probabilidade. Este intervalo pode ser especificado 
como (y-L) ≤ Y ≤ (y+L), Equação 7.1, ou Y = (y∓L), Equação 7.2.
y−L⩽Y⩽ y+L 7.1
Y= y∓L 7.2
Se X = { x1, x2, …, xn } são elementos de uma amostra aleatória, retirada de uma 
população, o intervalo definido pela Equação 7.3 é denominado intervalo de confiança da 
média com significância estatística α, com 1-α de probabilidade de contê-la, isto é, P[L i < m 
< Ls]=1-α.
(m−t1−α ,n−1
s
√n
;m+t1−α ,n−1
s
√n
) ou m∓t1−α ,n−1
s
√n
7.3
Em que t1-α,n-1 é ponto crítico da distribuição t-Student bicaudal, com n-1 graus de 
liberdade.
O valor de L são calculados a partir das observações X da amostra e 1-α é o nível de 
confiança associado ao intervalo.
Exemplo 7.1 Seis cargas de trabalho semelhantes foram utilizados em um sistema. As 
observações são {5,4 6,6 3,6 4,4 5,6}. Estime o intervalo de confiança da média destas 
observações com significância de 5%.
Confiança: 1-α = 1-0,05 = 0,95
Número de observações: n = 5
Média: m = ( 5,4 + 6,6 + 3,6 + 4,4 + 5,6 )/5 = 25,6 /5 = 5,1
Variância da amostra: [(5,4-5,5)2+(6,6-5,5)2+(3,6-5,5)2+(4,4-5,5)2+(5,6-5,5)2]1/2/5 = 1,3
Desvio padrão da amostra: s = 1,2
Intervalo de confiança: 5,1 ∓ t0,95;5ˣ1,2/61/2 = 5,1 ∓ 0,49t0,95;5
O valor t0,95;5 é o quantil 0,95 de uma variável t com cinco graus de liberdade, cujo valor 
2,571 (bicaudal)
Intervalo de confiança: 5,1 ∓ 0,49ˣ2,571=(3,8;6,4)
O intervalo de confiança da média é (3,8;6,4) com 95% de confiança.
Modelagem e Simulação Discreta 98
Conclusão: repetir estas observações reiteradas vezes, serão obtidas médias com valores 
deste 3,8 até 6,4 em 95% dos casos, quanto maior o número de repetições mais 
evidenciadas serão estas estatísticas. Pode-se observar médias fora deste intervalo, acima 
e abaixo, em até 5% dos casos.
Para calcular xc = t1-α,n-1 deve-se resolver a equação integral ∫
−xc
+xc
f (x )dx=1−α em que 
f (x )= 1
ν
1
2Β( 1
2
, ν
2
)
(1+ x ²
ν )
−ν+1
2 é a distribuição t-Student bicaudal com ν graus de 
liberdade e B é a função beta.
Considerando a simetria da distribuição t-Student, os limites de integração podem ser 
mudados de [-xc,+xc] para [0,+xc] e 1-α para (1-α)/2, estes valores podem ser calculados a 
partir de ∫
0
+xc
f (x )dx=1−α
2
ou obtidos de tabelas estatísticas, que são feitas com soluções 
destas equações integrais.
Modelagem e Simulação Discreta 99
7.1.2 Método das Médias de Lotes
Em geral, o Método de Médias de Lotes (MML) é usado para se estimar a variância ou 
calcular ICs para a média μ de processos de estado estacionário. Ele consiste em dividir uma 
longa rodada de simulação em um número de lotes contíguos e utilizar o Teorema Central do 
Limite para supor que as médias de lotes sejam aproximadamente normais e iid.
Figura 7.2 Representação gráfica do Método da Média de lotes.
Suponha que se particione { x1, x2, …, xn } em l lotes contíguos, disjuntos, cada um com 
b observações, sendo n = l⋅b. Assim, o i-ésimo lote, i ∈ [1,l], consiste nas variáveis 
aleatórias x(i-1)b+1, x(i-1)b+2, …, xi⋅b. A média do i-ésimo lote é zi=
1
b∑j=1
b
x(i−1)b+ j , a média 
amostral das b observações do lote i.
O Quadro 7.2 apresenta um quadro com os l lotes do Método de Média de Lotes 
organizadas em linhas, cada lote com b pacotes organizados por coluna; num total de l x b 
pacotes. As médias dos lotes são calculadas por linha.
Quadro 7.2 Quadro com os l lotes do Método de Média de Lotes, cada lote com b pacotes e 
suas respectivas médias
Lote (i) Pacote (i+b) Média
1 x1 x2 … xj … xbz1
2 xb+1 xb+2 … xb+j … x2·b z2
… … … … … … … …
x(i-1)b+1 x(i-1)b+2 … x(i-1)b+j … xi·b zi
… … … … … … … …
l x(l-1)b+1 x(l-1)b+2 … x(l-1)b+j … xl·b zl
Modelagem e Simulação Discreta 100
Definindo o estimador V l=
1
l−1∑i=1
l
(z i−m)2 para as médias amostrais dos lotes, 
m=1
l∑i=1
l
zi . Se b é grande, então as médias amostrais dos lotes são aproximadamente 
Normais e iid. O valor de IC aproximado para a média populacional, μ, com 100×(1-α)% de 
confiança é μ.
μ∈{m∓t1−α , r−1√V r
r } 7.4
O uso da média de lotes pode resultar em intervalos de confiança de baixa cobertura se 
os xi não forem estacionários ou se as médias dos lotes não forem normais ou se as médias 
dos lotes não forem independentes.
Para melhorar o problema do viés da iniciação, pode-se truncar alguns dos dados ou 
fazer uma longa simulação. Além disso, a falta de independência ou de normalidade das 
médias dos lotes pode ser contornada pelo aumento do tamanho do lote, b.
Exemplo 7.2 Calcule o Intervalo de Confiança bilateral da média da população a partir das 
Médias de Lotes abaixo, α = 5%:
Lote Pacote Média
1 13,4 9,8 11,6 10,8 11,4
2 9,2 12,0 13,6 9,9 11,2
3 8,9 9,7 10,3 13,0 10,5
4 11,0 12,4 8,8 11,4 10,9
l = 4
b = 4
Cálculo dos zi:
z1 = (13,4 + 9,8 + 11,6 + 10,8)/4 = 11,4
z2 = (9,2 + 12,0 + 13,6 + 9,9)/4 = 11,2
z3 = (8,9 + 9,7 + 10,3 + 13,0)/4 = 10,5
z4 = (11,0 + 12,4 + 8,8 + 11,4)/4 = 10,9
Cálculo de m:
m = (11,4 + 11,2 + 10,5 + 10,9)/4 = 32,6/4 = 11,0
Cálculo de Vl:
Vl = [(11,4-11,0)2 + (11,2-11,0)2 + (10,5-11,0)2 + (10,9-11,0)2]/3 = 0,159
Cálculo de t1-0,5;3 = t0,95;3 = 3,1824 (valores tabelados – tabela bicaudal)
Cálculo do IC:
μ = 11,0 ∓ 3,1824 x (0,159/4)1/2 = 11,0 ∓ 3,1824 x 0,199 = 11,0 ∓ 0,634
Modelagem e Simulação Discreta 101
Conclusão: média da população μ ∈ [10,4;11,6] com 95% de confiança.
O item 15.3 contém o software SF.MM1-ML-RI.cpp que implementa o Método da Média de 
Lotes (MML).
7.1.3 Método de Replicação Independente
O Método das Replicações Independentes (MRI) estima V(m) através da realização de r 
simulações independentes (amostras ou replicações) do modelo do sistema, em que cada 
replicação consiste em b pacotes simulados. Para fazer as replicações independentes, por 
exemplo, pode-se reiniciar cada replicação com uma semente diferente.
Figura 7.3 Representação gráfica do Método das Replicações Independentes.
Seja zi=
1
b∑j=1
b
x ij a média amostral da replicação i, onde xij é a observação j da 
replicação i, para i ∈ [1,r] e j ∈ [1,b].
A Quadro 7.3 apresenta um quadro com as r simulações com o Método de Replicação 
Independentes organizadas em linhas, cada simulação com b pacotes organizados por 
coluna; num total de r x b pacotes. As médias das replicações são calculadas por linha.
Quadro 7.3 Quadro com r simulações com o Método de Replicação Independente, cada 
repetição com b pacotes e suas respectivas médias
Repetição (i)
Pacote (j)
Média
1 2 … j … b
1 x1,1 x1,2 … x1,j … x1,b z1
2 x2,1 x2,2 … x2,j … x2,b z2
Modelagem e Simulação Discreta 102
… … … … … … … …
i xi,1 xi,2 … xi,j … xi,b zi
… … … … … … … …
r xr,1 xr,2 … xr,j … xr,b zr
Se cada simulação inicia com as mesmas condições operacionais (como filas vazias e 
servidores ociosos). As médias amostrais das replicações {z1, z2, …, zr} são variáveis 
aleatórias iid e, então, o estimador da variância das médias amostrais, Vr, é
V r=
1
r−1∑i=1
r
(zi−m)2 em que m=1
r∑i=1
r
zi .
Se o número de observações por replicação, r, é suficientemente grande, o Teorema 
Central do Limite afirma que as médias amostrais das replicações são aproximadamente 
Normais e iid. Assim, a estatística básica fornece um intervalo de confiança (IC) bilateral 
aproximado de 100×(1-α)% de confiança para a média populacional, μ.
μ∈{m∓t1−α , r−1√V r
r } 7.5
Exemplo 7.3 Calcule o Intervalo de Confiança bilateral da média da população a partir das 
Replicações Independente abaixo, α = 5%:
Repetição 
(i)
Pacote
Média
1 2 3 4 5 6
1 12,2 14,3 9,7 11,4 13,1 11,3 12,0
2 11,4 10,2 9,3 13,1 12,0 11,8 11,3
3 10,7 11,1 13,0 10,4 11,3 11,4 11,3
4 13,2 10,4 10,7 11,5 9,2 10,2 10,9
r = 4
b = 6
Cálculo dos zi:
z1 = (12,2 + 14,3 + 9,7 + 11,4 + 13,1 + 11,3)/6 = 72,0/6 = 12,0
z2 = (11,4 + 10,2 + 9,3 + 13,1 + 12,0 + 11,8)/6 = 67,8/6 = 11,3
z3 = (10,7 + 11,1 + 13,0 + 10,4 + 11,3 + 11,4)/6 = 67,9/6 = 11,3
z4 = (13,2 + 10,4 + 10,7 + 11,5 + 9,2 10,2)/6 = 65,2/6 = 10,9
Cálculo de m:
m = (12,0 + 11,3 + 11,3 + 10,9)/4 = 45,48/4 = 11,4
Cálculo de Vr:
Vr = [(12,0-11,4)2 + (11,3-11,4)2 + (11,3-11,4)2 + (10,9-11,4)2]/3 = 
Modelagem e Simulação Discreta 103
(0,396+0,005+0,003+0,254)/3 = 0,658/3 = 0,219
Cálculo de t1-0,05;3 = t0,95;3 = 3,1824 (valores tabelados – tabela bicaudal)
Cálculo do IC:
μ = 11,4 ∓ 3,1824 x (0,219/4)1/2 =11,4 ∓ 3,1824 x 0,230 = 11,4 ∓ 0,750
Conclusão: média da população μ ∈ [10,6;12,12] com 95% de confiança.
O item 15.3 contém o software SF.MM1-ML-RI.cpp (Programa 15.2) que implementa o 
MRI.
7.2 Critério de Parada
A qualidade e confiança de uma simulação depende do intervalo de confiança dos seus 
resultados. O software que faz a simulação pode utilizar como critério de parada valores 
calculados de IC. Por outro lado, o número de simulações pode previamente determinado, 
dado pelo valor N, neste caso o engenheiro é o responsável por validar os resultados.
7.2.1 Intervalo de Confiança como Critério de Parada
O critério de parada pela estimativa da variância utiliza o conceito de tamanho de 
amostras, segue-se que a simulação deve ser executada até que o intervalo de confiança 
para a resposta média se restrinja a um intervalo desejado, Figura 7.4. Se a média da 
amostra é m e sua variância é V(m), o intervalo de confiança para a média é dada por
m∓z1−αV (m) em que ∓z1−α é o 1-α quantil de uma variável normal unitária.
Figura 7.4 Variação de E[tsf] versus o número de pacotes numa simulação de Sistema de Fila 
M/M/1.
Modelagem e Simulação Discreta 104
7.2.2 N como Critério de Parada
Um outro critério de parada, mais simples, é usar o Método RI ou o Método ML adotando 
um valor muito grande para N como, por exemplo, N = 5000. Tendo em vista que o estado 
estacionário pode ser alcançado para grandes valores de N, como mostrado na Figura 7.4. Ao 
avaliar os ICs dos resultados obtidos, pode-se ajustar o valor de N.
Softwares que utilizam N fixo são mais simples do que os que usam intervalos de 
confiança como critério de parada (N variável).
O valor de N grande o suficiente para que a simulação alcance o estado estacionário 
depende de ρ (ρ=λ/μ). Pode-se observar experimentalmente que para ρ = 1 e N muito 
grande, obtém valores de tsf e nf também muito grandes e U ≈ 1, tais simulações não são 
úteis.
Pode-se usar N = 5000 para valores de ρ ≈ 0,75. Entretanto, recomenda-se fortemente 
avaliar os valores dos intervalos de confiança dos resultados para julgar a qualidade das 
simulações e fazer os ajuste do valor de N quando necessário.
7.3 Que Nível de Confiança Estatística Usar
Tem sido usado o nível de confiança estatística de 95%. Isso não deve levar a conclusão 
que os níveis de confiança devem ser sempre altos. A escolha do nível de confiança baseia-
se na relação entre a perda se o parâmetro está fora do intervalo e o ganho se o parâmetro 
está dentro do intervalo. Se a perda é alta em comparação com o ganho, os níveis de 
confiança devem ser elevados. Se a perda é insignificante em comparação com o ganho, um 
nível de confiança menor é suficiente.
Ao se deparar com um parâmetro que é significativo apenas no nível de confiança de 
50%, não deve ser assumido automaticamente que a confiança é baixa e que não se deve 
tomar decisões com base nesse parâmetro. Da mesma forma, mesmo que um parâmetro 
seja significativo ao nível de confiança de 99%, é possível que o nível de confiança não seja 
suficientemente elevado se a perda devidaà decisão errada for enorme.
O valor do nível de confiança deve ser contextualizado para cada caso.
7.4 Software SF.MM1-ML-RI.cpp
Modelagem e Simulação Discreta 105
Foi desenvolvido o software SF.MM1-ML-RI.cpp, Programa 15.2 do item 15.3 , para gerar 
dados para os Métodos de Médias de Lotes (ML) de Replicações Independentes (RI).
O método RI requer dados de entrada: N, l, m, R (número de repetições) e P 
(percentagem de N). O método RI gera um aquivo de saída com formato csv que pode ser 
manipulado por planilhas, permitindo outras análises estatísticas. O Quadro 7.4 apresenta os 
resultados da execução do SF.MM1-ML-RI.cpp para N = 5000, l = 40, m = 50, R = 10 e P = 
10.
Quadro 7.4 Resultado da execução da Replicação Independe do software SF.MM1-ML-RI.cpp 
para N = 5000, l = 40, m = 50, R = 10 e P = 10.
R Pi Pf T E[tsf] E[nf] U
1 4500 4999 12,317 0,021 4,400 0,840
2 4500 4999 11,884 0,020 4,400 0,857
3 4500 4999 12,340 0,020 3,812 0,816
4 4500 4999 12,998 0,021 4,840 0,801
5 4500 4999 12,963 0,021 3,242 0,798
6 4500 4999 12,829 0,021 4,762 0,804
7 4500 4999 11,670 0,019 4,546 0,833
8 4500 4999 12,868 0,020 3,906 0,766
9 4500 4999 12,443 0,019 3,158 0,768
10 4500 4999 12,694 0,020 4,092 0,798
Em que Pi e Pf indicam pacotes iniciais e finais.
O método ML requer dados de entrada: l, m, L(número de lotes) e B(tamanho de lote). O 
método ML gera um aquivo de saída com formato csv que pode ser manipulado por planilhas, 
permitindo outras análises estatísticas. O Quadro 7.5 apresenta os resultados da execução do 
SF.MM1-ML-RI.cpp para l = 40, m = 50, L = 10 e B = 500.
Quadro 7.5 Resultado de uma execução da Média de Lotes do software SF.MM1-ML-RI.cpp 
para l = 40, m = 50, L = 10 e B = 500.
B Pi Pf T E[tsf] E[nf] U
1 0 499 11,766 0,125 4,910 0,909
2 500 999 13,057 0,087 3,208 0,779
3 1000 1499 12,344 0,076 2,994 0,755
4 1500 1999 13,197 0,121 4,510 0,810
5 2000 2499 11,694 0,070 2,714 0,801
Modelagem e Simulação Discreta 106
6 2500 2999 12,185 0,079 2,990 0,845
7 3000 3499 12,325 0,150 6,114 0,883
8 3500 3999 12,350 0,214 9,058 0,855
9 4000 4499 11,407 0,124 5,298 0,851
10 4500 4999 12,317 0,104 4,400 0,840
Em que Pi e Pf indicam pacotes iniciais e finais.
Por meio de planilha pode-se calcular os valores da média (m), desvio padrão (s), 
intervalo de confiança (IC) para α = 5% e n = 10 e a covariância (Cov) dos resultados do 
Quadro 7.5, conforme descrito abaixo, o que permite interpretar os resultados.
E[tsf] E[nf] U
m 0,1150 4,61 0,8328
s 0,0434 1,92 0,0469
IC [0,084; 0,146] [3,24; 6,00] [0,799; 0,866]
Cov (%) 37,8 41,7 5,64
Modelagem e Simulação Discreta 107
7.5 Revisão
Modelagem e Simulação Discreta 108
7.6 Questões
1. Como os métodos RI e ML tratam os transientes?
2. Qual a utilidade de combinar os métodos RI e remoção de transientes?
3. Qual a utilidade de combinar os métodos ML e remoção de transientes?
7.7 Exercícios
1. Foram realizadas 4 rodadas de simulação, cada uma com 300 pacotes. Os dados de 
E[nf], E[tsf] e p0 estão listados abaixo. Calcule:
a) Intervalo de Confiança da média (μ) de E[nf], E[tsf] e U para α = 10%, α = 5% e α = 
1%.
b) Intervalo de Confiança da variância (σ2) de E[nf], E[tps] e p0 para α = 10%, α = 5% e 
α = 1%.
E[nf]
i/j 1 2 3 4 5 6 7 8 9 10
1 4 3 2 2 3 3 3 4 3 2
2 7 5 4 5 5 4 4 7 4 4
3 12 18 7 2 8 8 6 9 10 6
4 20 3 13 5 4 12 9 7 8 9
E[tsf]
i/j 1 2 3 4 5 6 7 8 9 10
1 1.83 1.83 1.83 1.71 1.83 1.98 1.86 1.83 1.71 1.74
2 2.13 2.04 2.01 2.16 2.13 1.86 2.07 2.07 1.98 2.07
3 2.40 2.52 2.4 2.34 2.34 2.31 2.46 2.25 2.46 2.40
4 2.64 2.94 2.58 2.88 2.70 2.55 2.85 2.55 2.79 2.58
p0
i/j 1 2 3 4 5 6 7 8 9 10
1 0.373 0.346 0.385 0.374 0.362 0.347 0.397 0.340 0.408 0.475
2 0.256 0.252 0.341 0.264 0.275 0.355 0.330 0.231 0.322 0.374
3 0.181 0.108 0.200 0.171 0.216 0.230 0.197 0.195 0.149 0.278
4 0.116 0.008 0.165 0.033 0.022 0.134 0.078 0.116 0.031 0.190
2. Foi realizada uma rodada de simulação com 50 pacotes, abaixo relacionados. Calcule a) 
Intervalo de Confiança da média (μ) de tsf para α = 10%, α = 5% e α = 1%.
p tsf p tsf p tsf p tsf p tsf p tsf
1 0,404 51 4,476 101 0,018 151 0,016 201 0,017 251 1,321
2 1,955 52 0,017 102 3,169 152 3,266 202 0,408 252 0,716
Modelagem e Simulação Discreta 109
3 0,271 53 0,015 103 1,342 153 0,720 203 1,203 253 0,017
4 0,829 54 1,373 104 0,362 154 0,309 204 0,018 254 0,378
5 0,499 55 1,720 105 0,961 155 0,013 205 0,036 255 6,478
6 0,208 56 2,215 106 0,225 156 1,066 206 1,989 256 0,164
7 2,173 57 0,281 107 0,548 157 0,012 207 0,205 257 0,212
8 2,431 58 0,432 108 0,017 158 0,898 208 0,101 258 0,057
9 2,904 59 0,059 109 0,301 159 0,067 209 0,012 259 1,737
10 0,033 60 0,391 110 3,862 160 0,189 210 2,285 260 0,820
11 3,395 61 0,011 111 0,090 161 0,037 211 0,913 261 6,078
12 0,026 62 0,123 112 5,624 162 1,260 212 0,259 262 0,097
13 0,127 63 0,160 113 1,156 163 0,092 213 0,554 263 0,126
14 0,059 64 2,769 114 0,044 164 0,009 214 0,090 264 0,137
15 0,098 65 2,005 115 0,082 165 0,038 215 0,045 265 0,778
16 2,198 66 1,549 116 1,832 166 1,421 216 3,903 266 0,491
17 0,024 67 0,030 117 0,018 167 0,075 217 0,037 267 0,029
18 0,010 68 0,058 118 0,018 168 0,051 218 0,014 268 0,446
19 0,130 69 0,015 119 0,729 169 0,042 219 0,891 269 0,960
20 0,300 70 0,016 120 0,049 170 0,362 220 0,114 270 0,101
21 0,145 71 0,053 121 0,132 171 0,809 221 0,332 271 0,056
22 0,792 72 0,136 122 0,456 172 0,015 222 0,245 272 2,138
23 0,019 73 2,812 123 0,112 173 0,046 223 0,236 273 3,339
24 5,175 74 4,056 124 0,112 174 5,506 224 0,094 274 1,143
25 0,038 75 0,010 125 0,390 175 3,050 225 2,759 275 0,017
26 0,256 76 0,883 126 0,014 176 3,730 226 0,475 276 6,556
27 1,411 77 1,156 127 0,602 177 0,559 227 6,327 277 0,026
28 0,023 78 0,074 128 2,128 178 0,010 228 0,010 278 0,336
29 0,155 79 4,526 129 1,431 179 2,912 229 3,210 279 1,251
30 0,195 80 0,026 130 1,960 180 0,143 230 0,081 280 1,006
31 4,262 81 0,088 131 0,764 181 0,359 231 0,061 281 3,183
32 1,030 82 0,010 132 5,004 182 6,021 232 0,052 282 0,091
33 3,494 83 0,053 133 0,093 183 0,236 233 0,582 283 0,036
34 3,851 84 0,014 134 0,430 184 0,009 234 0,016 284 0,917
35 0,285 85 4,128 135 1,163 185 0,128 235 0,013 285 0,013
36 5,334 86 0,190 136 2,220 186 0,055 236 0,537 286 0,026
37 0,110 87 0,092 137 1,041 187 1,142 237 0,018 287 0,410
38 0,023 88 0,081 138 0,011 188 0,023 238 5,487 288 0,009
39 0,747 89 0,352 139 2,125 189 2,876 239 0,018 289 0,126
40 2,567 90 0,901 140 0,014 190 0,055 240 2,864 290 0,022
41 0,100 91 3,335 141 4,777 191 2,458 241 3,516 291 0,009
42 2,170 92 3,692 142 6,056 192 0,429 242 4,778 292 0,016
43 0,186 93 0,129 143 0,081 193 0,016 243 5,460 293 0,057
44 2,922 94 0,033 144 0,418 194 5,417 244 1,292 294 0,022
45 1,588 95 0,016 145 0,146 195 0,126 245 0,507 295 0,422
46 0,049 96 0,010 146 0,526 196 0,223 246 4,404 296 2,829
47 0,492 97 1,631 147 0,365 197 0,468 247 0,035 297 0,364
48 1,356 98 0,304 148 0,021 198 0,230 248 0,115 298 0,020
49 0,353 99 0,775 149 0,052 199 0,022 249 0,029 299 0,028
50 0,400 100 0,045 150 0,252 200 0,125 250 0,804 300 0,242
3. Utilize o software SF.MM1-ML-RI.cpp descrito no Anexo para realizar B rodadas de 
simulação, cada uma com M eventos e calcule os Intervalos de Confiança da média (μ) 
e da variância (σ2) de nf, tf, tps e tsf para α = 10%, α = 5% e α = 1% nos casos:
a) B = 10 e M = 2000
b) B = 10 e M = 4000
c) B = 10 e M = 6000
4. Compare estes resultados.
5. Modifique o software SF.MM1-ML-RI.cpp descrito no Anexo para realizar B rodadas de 
simulação, cada uma com M eventos e calcule os Intervalos de Confiança da média (μ) 
e da variância (σ2) de p0 para α = 10%, α = 5% e α = 1% nos casos:
Modelagem e Simulação Discreta 110
a) B = 10 e M = 2000
b) B = 10 e M = 4000
c) B = 10 e M = 6000
6. Compare estes resultados.
7. Utilize o software SF.MM1-ML-RI.cpp descrito no Anexo para realizar rodadas de 
simulação com N eventos e calcule os Intervalos de Confiança da média (μ) e da 
variância (σ2) de ic, ts, nf, p0, tf e tsf para α= 10%, α = 5% e α = 1% nos casos:
a) N = 1000
b) N = 10000
c) N = 100000
8. Compare estes resultados.
Modelagem e Simulação Discreta 111
8 SIMULAÇÃO DE SISTEMAS COMPUTACIONAIS
São diversos os sistemas computacionais, a Figura 8.1 representa um exemplo simples 
de um sistema de computação, constituído por um Servidor Web (Sw) conectado à Internet 
por meio de um Switch (S). Neste sistema, mensagens da Internet são recebidas pelo Switch 
que as envia para o Servidor Web. O Servidor Web recebe estas mensagens, processa-as, e 
as enviam de volta para o Switch. O Switch recebe as mensagens do Servidor Web e as envia 
de volta à Internet.
Considerando o sistema computacional da Figura 8.1, se a taxa de serviços de chegada 
no Switch for menor ou igual que sua capacidade de processamento então ele enviará os 
serviços ao Servidor Web num fluxo contínuo senão serviços serão armazenados na memória 
do Switch para posterior processamento. Neste caso, diz-se que os serviços estão sendo 
colocados em uma fila do Switch. Semelhante raciocínio é válido para os demais elementos 
do sistema.
Figura 8.1 Sistema computacional, Servidor Web (Sw) conectado a rede internet por meio de 
um Switch (S).
O sistema computacional da Figura 8.1 pode ser modelado por dois sistemas de filas em 
série como mostrado na Figura 8.2, o primeiro para o processo de chegada no Switch e o 
segundo para o Servidor Web. A taxa de entrada de serviços do Switch é a que chega da 
Internet. Após processar os serviços, o Switch os envia para o Servidor Web. A taxa de 
entrada de serviços no Servidor Web é a taxa de saída do Switch. Após processar os serviços, 
o Servidor Web os envia para o Switch. A taxa de entrada de serviços no Switch é a mesma 
Modelagem e Simulação Discreta 112
que sai do Servidor Web. Por fim, após processar os serviços, o Switch os envia para a 
Internet.
Figura 8.2 Modelo de um sistema computacional por meio de filas.
Pode-se modelar os elementos de sistemas computacionais por meio de uma rede de 
sistemas de filas, um sistema de filas para cada elemento.
A arquitetura de um sistema de hardware é mostrado na Figura 8.3, um diagrama de 
blocos de nível de sistema do Sun Fire X4150 Server com Serial Attached SCSI – SAS. Estes 
servidores foram projetados para fornecer o melhor desempenho com alta confiabilidade e 
baixo consumo de energia. Eles possuem múltiplos processadores que se conectam a um 
controlador de memória Northbridge Hub (MCH) que, por sua vez, se conecta a um 
Southbridge I/O (IOH) e seus subsistemas (Sun Microsystems, 2016).
Figura 8.3 Diagrama de blocos do Sun Fire X4150 Server com Serial Attached SCSI – SAS (Sun 
Microsystems, 2016).
Modelagem e Simulação Discreta 113
A simulação de sistemas computacionais permite estudar seu comportamento de modo 
detalhado e fazer previsões sobre o mesmo.
8.1 Modelo de Rede de Sistemas de Fila (RSF)
Os modelos de Rede de Sistemas de Fila (RSF) representam sistemas computacionais 
por meio de Sistemas de Filas (SF) interconectadas e com topologia bem definida. As RSFs 
A/B/c/K/m/Z podem ser simuladas por computador e, inicialmente será apresentado o modelo 
conceitual de uma RSF com SF M/M/1 e, em seguida, o seu modelo computacional será 
discutido e implementado em C++. A dinâmica temporal de uma RSF típica será apresentada 
no formato de tabelas permitindo o acompanhamento de suas variáveis de entrada, de 
estado e de saída.
No Capítulo 2 foram apresentados os Modelos Conceitual e Computacional de Sistemas 
de Fila M/M/1. A diferença principal entre os modelos de um simples SF e RSFs é que, por 
haver mais de um SF, o primeiro SF terá dados de entrada e, a partir do segundo SF, os 
dados de entrada serão os dados de saída do SF anterior, Figura 8.4.
Figura 8.4 Rede de Sistemas de Fila indicando o fluxo de dados de entrada (ic) do primeiro 
Sistema de Fila e a sua saída (is – intervalo entre saída) como entrada para o próximo 
Sistema de Fila.
8.2 Modelo Conceitual de RSF
Um Modelo Conceitual de uma RSF de Filas M/M/1 será apresentado e discutido e, a 
partir dele, modelos envolvendo Filas M/M/c/K/m podem ser derivados dele.
Nos Sistemas de Fila das RSFs, os pacotes chegam um por vez e são processados 
igualmente um por vez. Desta forma, os Sistemas de Fila de uma RSF possuem três variáveis 
básicas:
1. taxa de chegada (λ) e seu correspondente intervalo entre chegadas (ic), ic = 1/E[λ]
2. taxa de serviço (μ) e seu correspondente tempo de serviço (ts), ts = 1/E[μ]
3. taxa de saída (γ) e seu correspondente intervalo entre saídas (is), is = 1/E[γ]
A Figura 8.5 ilustra o Modelo Conceitual de um Sistemas de Fila M/M/1 de uma RSF. 
Conforme enfatizado, a saída dos SFs torna-se importante no caso de RSFs.
Modelagem e Simulação Discreta 114
Figura 8.5 Modelo conceitual de um Sistemas de Fila em rede.
Numa Rede de Sistemas de Filas (RSF), os pacotes deve ser processados em cada um 
dos Sistemas de Filas, sequencialmente, de acordo com a arquitetura da rede. A saída do 
Servidor anterior serve de entrada para a Fila do próximo Sistema de Fila. Os dados de 
entrada da Rede de Filas são os intervalos entre chegadas na primeira Fila e os dados de 
saída de cada Servidor do Sistema de Filas. Os parâmetros da Rede de Filas são:
• os valores de A/B/c/K/m/Z de cada SF
• sequência dos pacotes, r
• número de pacotes para simular, N
• λ do primeiro SF
• μ de cada SF, d
Será utilizado um estudo de caso da Figura 8.6 para apresentar o modelo conceitual de 
Redes de Sistemas de Filas tendo em vista que há muitas combinações possíveis de Sistemas 
de Filas. A partir de deste estudo de caso, pode-se generalizar o modelo proposto.
Modelagem e Simulação Discreta 115
Figura 8.6 Esquema do estudo de caso de uma Rede de Sistemas de Fila.
A RSF da Figura 8.6 possui 4 SF, numeradas de 0 a 3: SF0, SF1, SF2 e FS3. Os parâmetros 
desta rede são:
• os SF da RSF são M/M/1
• sequência dos pacotes: 0 → 1, 1 → 2, 2 →1, 1→ 3, 3→ 0, logo r = [ 0, 1, 2, 1, 3, 0 ]
• número de pacotes, N (definido pelo usuário)
• λ0 e m = [ μ0, μ1, μ2, μ3 ]
Em resumo, os parâmetros da RSF da Figura 8.6, para 5000 pacotes: N = 5000, l0, m = [ 
m0, m1, m2, m3 ] e r = [ 0, 1, 2, 1, 3, 0 ].,
Nota sobre a sequência de pacotes numa RSF
O nível de detalhes do modelo de sequência dos pacotes é a visão de pior caso, à maneira 
da Ciência da Computação Clássica. A trajetória de um pacote numa rede pode variar com 
a natureza do próprio pacote e da rede, assim há várias sequências possíveis para os 
pacotes. Visando uma modelagem simples sem perder precisão, adotou-se o critério de 
pior caso: todos pacotes seguem a maior sequência possível na rede. Esta 
abordagem simplifica:
• a compreensão do problema
• o modelo conceitual
• o modelo computacional
Esta abordagem também é a favor da segurança da solução uma vez que superestima os 
resultados mas não dispensa, pelo contrário, requer a supervisão de engenheiro após a 
implantação da solução, para ajustes que se fizerem necessários.
8.3 Valores Iniciais da Simulação de RSF
A condição mais simples para iniciar a simulação de uma RSF é zerar o cronômetro com 
as Filas vazias e os Servidores ociosos. Ou seja, zerar tudo, o cronômetro e o número de 
pacotes na RSF.
Modelagem e Simulação Discreta 116
Como há uma correspondência entre o vetor m e o número de SF, o número de 
elementos de m é igual ao número de SF, pode-se escrever que SFi está relacionado com mi. 
Pode-se pensar também que mi é o mesmo que m[i]. O índice i será associado aos Sistema 
de Fila. 
Como visto na Figura 8.4, uma RSF é um encadeamento de SF, a sequência dos pacotes 
neste encadeamento é dado pelo vetor r, que define o roteamento dos pacotes desde a 
entrada até a saída do sistema.
Observe que não há uma correspondência entre o número de SF e o número de 
elementos de r. O vetor r determina o caminhoque um pacote percorre na RSF, uma rota 
longa tem uma sequência com várias SF, incluindo SF repetidas.
Um pacote entra na RSF no r0, segue para o r1 e assim por diante, percorrendo todo 
vetor r, ou seja: r0 → r1 → r2 → … → ri → … Pode-se pensar também que ri é o mesmo que r[i]. 
O índice i será associado ao roteamento.
Observe que ri é algum dos SF de RSF, para este texto r0 é o SF0. Vale ressaltar que r0 
pode ser um outro SF, depende apenas da configuração da RSF.
8.4 Roteamento do Primeiro Pacote (p=0)
Os pacotes percorrem uma RSF de acordo com o encadeamento dado pelo vetor r. Os 
pacotes são processados em cada SF da rede, nos quais são calculados seus eventos e 
demais variáveis de estado.
O primeiro pacote (p=0) que entra na RSF requer tratamento diferenciado pois não há 
pacote antes dele. Por outro lado, r0 também requer tratamento diferenciado pois não há SF 
antes dele.
O r0.ic0 é duplamente diferenciado pois é o primeiro pacote (p = 0) no primeiro SF(r0). O 
intervalo entre chegadas do primeiro pacote (ic0) no primeiro SF da RSF(r0) é r0.ic0 = X(r0.λ). 
Em resumo, os valores do pacote p = 0 e r0 são calculados como descrito abaixo:
▪ r0.ic0 = X(r0.λ)
▪ r0.cpf0 = r0.ic0
▪ r0.eps0 = r0.cpf0
▪ r0.sps0 = r0.eps0 + X(r0.μ)
▪ r0.is0 = r0.sps0
Ao sair de r0 o primeiro pacote segue o encadeamento dado pelo vetor r e, 
generalizando, os valores de p = 0 e ri, i > 0, são calculados como descrito abaixo: 
▪ ri.ic0 = ri-1.is0
▪ ri.cpf0 = ri.ic0
Modelagem e Simulação Discreta 117
▪ ri.cpf0 = ri.cpf0
▪ ri.sps0 = ri.eps0 + X(r0.μ)
▪ ri.is0 = ri.sps0
Observe que apenas ri.ic0 é feito com dados do SF que o antecede, representado por ri-1. 
Os demais são calculados com dados do próprio SF, representado por ri.
Para fins computacionais, uma maneira prática de tratar o pacote p = 0 é fazer:
ri.ic0 = ri.cpf0 = ri.epsf0 = ri.sps0 = ri.is0 = ri.nf0 = 0, i ≥ 0.
8.5 Roteamento dos Demais Pacotes (p>0)
Os pacotes que sucedem o primeiro na RSF, podem ser tratados de modo genérico como 
p, p ∊ (0,N).
O pacote p, p > 0, que entra na RSF no r0 é especial no tocante a r0.icp pois não tem SF 
que o antecede e, neste, r0.icp = X(r0.λ), caso contrário r0.icp = ri-1.isp, ou seja, o valor de is do 
SF que o antecede. Os demais valores destes pacotes dependem do mesmo SF e do pacote 
anterior.
Generalizando, os valores de p, p > 0 e ri, i ≥ 0, são calculados como descrito abaixo:
▪ ri.icp = i > 0 ? ri-1.isp : X(ri.λ)
▪ ri.cpfp = ri.icp + ri.cpfp-1
▪ ri.epsp = ri.cpfp > ri.spsp-1 ? ri.cpfp : ri.spsp-1
▪ ri.spsp = ri.epsp + X(ri.μ)
▪ ri.isp = ri.spsp + ri.spsp-1
Observe que apenas ri.icp (i > 0) é feito com dados do SF que o antecede, representado 
por ri-1. Os demais valores são calculados com dados do próprio SF, representado por r i, 
utilizando dados do próprio pacote (ri.icp, ri.cpfp, ri.epsp, ri.spsp) ou de pacotes anteriores do 
mesmo SF (ri.cpfp-1, ri.spsp-1).
O cálculo de nf de cada SF é feito de forma semelhante ao Sistema de Fila Simples.
Modelagem e Simulação Discreta 118
8.6 Revisão das RSF
Configuração das RSF M/M/1:
N, SF = [0, 1, 2, …, s, …], λ0, μ = [μ0, μ1, μ2, …, μs, …], r = [r0, r1, r2, …, ri, …], ri ∊ SF
Pacote r
p = 0 r = 0
r0.ic0 = X(r0.λ)
r0.cpf0 = r0.ic0
r0.eps0 = r0.cpf0 
r0.sps0 = r0.eps0 + X(r0.μ)
r0.is0 = r0.sps0
p = 0 r > 0
ri.ic0 = ri-1.is0
ri.cpf0 = ri.ic0
ri.eps0 = ri.cpf0
ri.sps0 = ri.eps0 + X(r0.μ)
ri.is0 = ri.sps0
p > 0 r = 0
r0.icp = X(r0.λ)
r0.cpfp = r0.icp + r0.cpfp-1
r0.epsp = r0.cpfp > r0.spsp-1 ? r0.cpfp : r0.spsp-1
r0.spsp = r0.epsp + X(r0.μ)
r0.isp = r0.spsp + r0.spsp-1
p > 0 r > 0
ri.icp = ri-1.isp
ri.cpfp = ri.icp + ri.cpfp-1
ri.epsp = ri.cpfp > ri.spsp-1 ? ri.cpfp : ri.spsp-1
ri.spsp = ri.epsp + = X(ri.μ)
ri.isp = ri.spsp + ri.spsp-1
for( int p = 1; p < N; p++ )
 for( int i = 0; i < r.size(); i++ )
 Empacota(r[i]);
Modelagem e Simulação Discreta 119
9 MODELO COMPUTACIONAL DE REDES DE SISTEMAS DE FILAS
O modelo computacional de RSF de Sistemas de Fila M/M/1 pode ser visto no Quadro 9.1. 
Ele é constituído por três classes, a saber: clPacote, clSF e clRSF. A classe clRSF possui um 
vetor de classes clSF e clSF possui um vetor de classes clPacote. O método Configurar 
configura os dados da RSF, Iniciar calcula os valores iniciais dos SFs, Simular executa as 
simulações fazendo uso do método Empacotar. Por fim, Nf calcula os valores de nf de cada 
SF. O cálculo das estatísticas não está implementado.
Quadro 9.1 Classe clRSFMM1 do Modelo Computacional dos Sistemas de Fila M/M/1
clPacote
 ic
 cpf
 eps
 sps
 is
 nf
clSF
 l
 m
 clPacote Pacote[]
clRSF
 r[]
 clSF SF[]
 X(p) 
 Iniciar( l, m[], r[] )
 Empacotar(i)
 Simular(N)
 Nf()
 Estatistica()
Veja mais detalhes a seguir.
Quadro 9.2 Descrição das classes do Modelo Computacional dos Sistemas de Fila M/M/1
clPacote pacotes dos SF com as variáveis de estado ic, cpf, eps, sps, is e nf
clSF são os SF da RSF, seus parâmetros l e m, e o vetor Pacote
Modelagem e Simulação Discreta 120
clRSF
representa a RSF, seus métodos e os vetores r e SF
• Iniciar – configura a RSF e o insere o primeiro pacote nos SFs
• X – calcula os valores de ic e ts dos pacotes simulados
• Empacotar – insere um novo Pacote no i-ésimo SF
• Simular – simula os pacotes de 1 a N-1 dos SFs
O Programa 9.1 implementa em C++ o modelo computacional básico de uma RSF 
M/M/1.
Programa 9.1 Código básico em C++ para simulação de Redes de Sistemas de Fila M/M/1
//--------------------------------------------------------------------------
#include <iostream>
#include <cstdlib>
#include <cmath>
#include <ctime>
#include <string>
#include <vector>
//--------------------------------------------------------------------------
using namespace std;
//--------------------------------------------------------------------------
class clPacote{
 public:
 int nf;
 double ic, cpf, eps, sps, is;
};
class clSF{
 public:
 double l, m;
 vector<clPacote> Pacote;
};
class clRSF{
 private:
 vector<int> r;
 vector<clSF> SF;
 double X ( double );
 void Empacotar( int );
 void Nf ( void );
 public:
 clRSF ( void );
 void Iniciar ( double, vector<double>, vector<int> );
 void Simular ( int );
};
clRSF::clRSF( void ){
 srand(time(nullptr));
}
double clRSF::X( double p ){
 double u = (rand()+1.0)/(RAND_MAX+2.0); // u in (0,1)
 return -log(u)/p;
}
Modelagem e Simulação Discreta 121
void clRSF::Iniciar( double l, vector<double> m, vector<int> r ){
 this->r = r;
 SF.clear();
 for( int s = 0; s < m.size(); s++ ){
 clSF X;
 X.l = l;
 X.m = m[s];
 X.Pacote.clear();
 SF.push_back(X);
 }
 for( int s = 0; s < r.size(); s++ ) // p = 0
 SF[r[s]].Pacote.push_back({0,0,0,0,0,0,0});
}
void clRSF::Empacotar( int i ){
 clPacote P, Pa;
 if( i > 0 ){
 Pa = SF[r[i-1]].Pacote[ SF[r[i-1]].Pacote.size()-1 ];
 P.ic = Pa.is;
 }
 else P.ic = X( SF[r[i]].l );
 Pa = SF[r[i]].Pacote[ SF[r[i]].Pacote.size()-1 ];
 P.cpf = P.ic + Pa.cpf;
 P.eps = P.cpf > Pa.sps ? P.cpf : Pa.sps;
 P.sps = P.eps + X(SF[r[i]].m);
 P.is = P.sps - Pa.sps;
 SF[r[i]].Pacote.push_back(P);
}
void clRSF::Simular( int N ){
 for( int p = 1; p < N; p++ )
 for( int i = 0; i < r.size(); i++ )
 Empacotar(i);
 Nf();
}
void clRSF::Nf( void ){
 for( int s = 0; s < SF.size(); s++ )
 for( int p = 1; p < SF[s].Pacote.size(); p++ ){
 SF[s].Pacote[p].nf = 0; 
 for( int a = p-1; a > 0; a-- )
 if( SF[s].Pacote[p].cpf < SF[s].Pacote[i].eps ) 
SF[s].Pacote[p].nf++;
 else break;
 }
 }
}
int main( void ){
 int N = 5000;
 vector<int> r = { 0, 1, 2, 3, 0 };
 double l = 500;
 vector<double> m = { 600, 700, 800, 900 };
 clRSF RSF;
 RSF.Iniciar(l,m,r);
 RSF.Simular(N);
 return 0;
}
Modelagem e Simulação Discreta 122O software RSF.MM1.cpp, escrito em C++, implementa o modelo computacional 
completo de uma RSF M/M/1 e pode ser visto no Programa 15.3, no item 15.4 .
A arquitetura do sistema é definida pelas variáveis l, m e r. A primeira indica a taxa de 
chegada na RSF, a segunda é o desempenho de cada Servidor dos SFs e a última indica o 
caminho percorrido pelos pacotes dentro da arquitetura definida.
As variáveis utilizadas no software RSF.MM1.cpp estão sumarizadas no Quadro 9.3.
Quadro 9.3 Variáveis utilizadas no software RSF.MM1.cpp
Nome Descrição
Entradas
N Número de pacotes
l Taxa de chegadas na RSF
m Vetor de taxas de serviço dos SF
r Ordem de visitas dos pacotes
Variáveis
ic Intervalo entre chegadas de pacotes na Fila
is Intervalo entre saídas de pacotes do Servidor
Eventos
cpf Tempo da chegada de pacotes na Fila
eps Tempo da chegada de pacotes no Servidor
sps Tempo da saída de pacotes no Servidor
Estatísticas
nf Comprimento da Fila
tsf Tempo no Sistema de Fila
U Utilização do Servidor
T Duração da simulação
Os resultados de uma simulação, feita com o software RSF.MM1.cpp (Programa 15.3) 
estão apresentados no Quadro 9.4. Devido ao uso de números aleatórios, os resultados da 
simulação podem variar a cada execução do software.
Quadro 9.4 Resultado da execução do software RSF.MM1.cpp para N = 10, l = 60 e m = { 30, 
30, 30, 30 } e r = { 0, 1, 2, 1, 3, 2, 1, 3, 2, 1, 0 }
Simulacao de Rede de Sistemas de Fila M/M/1
RSF Tabela
Numero de SF:4
Sequencia:0-1;1-2;2-1;1-3;3-2;2-1;1-3;3-2;2-1;1-0;
RSF l m
Modelagem e Simulação Discreta 123
0 60,000 30,000
1 - 30,000
2 - 30,000
3 - 30,000
SF: 0
p ic cpf eps sps nf is
0 0,000 0,000 0,000 0,000 0 0,000
1 0,000 0,000 0,000 0,000 0 0,000
2 0,022 0,022 0,022 0,065 0 0,065
3 0,148 0,171 0,171 0,189 0 0,124
4 0,019 0,190 0,190 0,210 0 0,021
5 0,028 0,218 0,218 0,239 0 0,029
6 0,017 0,235 0,239 0,265 1 0,026
7 0,001 0,236 0,265 0,280 2 0,015
8 0,004 0,240 0,280 0,372 2 0,093
9 0,102 0,342 0,372 0,387 1 0,014
10 0,009 0,351 0,387 0,415 2 0,028
11 0,038 0,389 0,415 0,421 1 0,006
12 0,011 0,400 0,421 0,499 2 0,078
13 0,014 0,414 0,499 0,548 3 0,048
14 0,004 0,418 0,548 0,548 3 0,001
15 0,075 0,493 0,548 0,554 3 0,005
16 0,004 0,497 0,554 0,595 4 0,041
17 0,127 0,624 0,624 0,629 0 0,034
18 0,013 0,637 0,637 0,693 0 0,064
19 0,107 0,744 0,744 0,838 0 0,144
SF: 1
p ic cpf eps sps nf is
0 0,000 0,000 0,000 0,000 0 0,000
1 0,000 0,000 0,000 0,000 0 0,000
2 0,000 0,000 0,000 0,000 0 0,000
3 0,000 0,000 0,000 0,000 0 0,000
4 0,065 0,065 0,065 0,068 0 0,068
5 0,073 0,138 0,138 0,146 0 0,078
6 0,242 0,380 0,380 0,385 0 0,239
7 0,140 0,520 0,520 0,533 0 0,148
8 0,021 0,541 0,541 0,553 0 0,020
9 0,015 0,556 0,556 0,560 0 0,007
10 0,049 0,605 0,605 0,633 0 0,073
11 0,001 0,605 0,633 0,661 1 0,028
12 0,026 0,631 0,661 0,723 2 0,062
13 0,061 0,692 0,723 0,728 1 0,005
14 0,008 0,700 0,728 0,799 2 0,071
15 0,051 0,752 0,799 0,800 1 0,001
16 0,093 0,845 0,845 0,866 0 0,066
17 0,084 0,929 0,929 0,974 0 0,109
18 0,125 1,054 1,054 1,073 0 0,098
19 0,068 1,122 1,122 1,174 0 0,102
20 0,028 1,150 1,174 1,260 1 0,086
21 0,117 1,266 1,266 1,295 0 0,035
22 0,013 1,279 1,295 1,303 1 0,008
23 0,002 1,281 1,303 1,342 2 0,038
24 0,078 1,359 1,359 1,361 0 0,019
25 0,043 1,402 1,402 1,409 0 0,048
26 0,119 1,521 1,521 1,539 0 0,130
27 0,032 1,553 1,553 1,553 0 0,014
28 0,001 1,554 1,554 1,561 0 0,008
29 0,020 1,574 1,574 1,588 0 0,026
30 0,224 1,798 1,798 1,848 0 0,260
31 0,101 1,898 1,898 1,922 0 0,075
32 0,041 1,940 1,940 1,955 0 0,032
33 0,009 1,949 1,955 2,002 1 0,048
34 0,020 1,969 2,002 2,011 1 0,009
Modelagem e Simulação Discreta 124
35 0,107 2,076 2,076 2,138 0 0,127
36 0,064 2,140 2,140 2,168 0 0,029
37 0,036 2,176 2,176 2,186 0 0,018
38 0,014 2,190 2,190 2,211 0 0,026
39 0,042 2,232 2,232 2,318 0 0,107
SF: 2
p ic cpf eps sps nf is
0 0,000 0,000 0,000 0,000 0 0,000
1 0,000 0,000 0,000 0,000 0 0,000
2 0,000 0,000 0,000 0,000 0 0,000
3 0,068 0,068 0,068 0,073 0 0,073
4 0,167 0,235 0,235 0,315 0 0,242
5 0,165 0,400 0,400 0,455 0 0,140
6 0,020 0,420 0,455 0,470 1 0,015
7 0,004 0,424 0,470 0,519 2 0,049
8 0,073 0,497 0,519 0,520 1 0,001
9 0,062 0,559 0,559 0,580 0 0,061
10 0,018 0,578 0,580 0,589 1 0,008
11 0,051 0,629 0,629 0,640 0 0,051
12 0,066 0,694 0,694 0,724 0 0,084
13 0,154 0,848 0,848 0,849 0 0,125
14 0,056 0,904 0,904 0,917 0 0,068
15 0,086 0,990 0,990 1,034 0 0,117
16 0,049 1,039 1,039 1,047 0 0,013
17 0,001 1,040 1,047 1,048 1 0,002
18 0,019 1,059 1,059 1,091 0 0,043
19 0,036 1,095 1,095 1,210 0 0,119
20 0,128 1,223 1,223 1,242 0 0,032
21 0,008 1,231 1,242 1,262 1 0,020
22 0,202 1,432 1,432 1,486 0 0,224
23 0,112 1,544 1,544 1,587 0 0,101
24 0,032 1,577 1,587 1,596 1 0,009
25 0,022 1,598 1,598 1,616 0 0,020
26 0,104 1,702 1,702 1,723 0 0,107
27 0,029 1,731 1,731 1,758 0 0,036
28 0,028 1,759 1,759 1,772 0 0,014
29 0,030 1,789 1,789 1,814 0 0,042
SF: 3
p ic cpf eps sps nf is
0 0,000 0,000 0,000 0,000 0 0,000
1 0,000 0,000 0,000 0,000 0 0,000
2 0,078 0,078 0,078 0,167 0 0,167
3 0,239 0,317 0,317 0,332 0 0,165
4 0,007 0,324 0,332 0,336 1 0,004
5 0,073 0,397 0,397 0,409 0 0,073
6 0,005 0,402 0,409 0,427 1 0,018
7 0,071 0,473 0,473 0,478 0 0,051
8 0,109 0,582 0,582 0,633 0 0,154
9 0,098 0,680 0,680 0,689 0 0,056
10 0,035 0,715 0,715 0,738 0 0,049
11 0,008 0,723 0,738 0,739 1 0,001
12 0,048 0,772 0,772 0,775 0 0,036
13 0,130 0,902 0,902 0,902 0 0,128
14 0,026 0,928 0,928 1,104 0 0,202
15 0,260 1,188 1,188 1,215 0 0,112
16 0,048 1,236 1,236 1,237 0 0,022
17 0,009 1,245 1,245 1,341 0 0,104
18 0,018 1,263 1,341 1,369 1 0,028
19 0,026 1,288 1,369 1,399 2 0,030
Resumo dos Indicadores por SF
SF T N E[ic] E[tsf] E[nf] E[is] DP[ic] DP[tsf] DP[nf] DP[is] U
0 0,838 20 0,037 0,056 1,200 0,042 0,046 0,043 1,288 0,040 0,733
Modelagem e Simulação Discreta 125
1 2,318 40 0,056 0,030 0,325 0,058 0,057 0,029 0,608 0,060 0,405
2 1,814 30 0,060 0,029 0,267 0,060 0,056 0,028 0,512 0,062 0,407
3 1,399 20 0,064 0,039 0,300 0,070 0,072 0,048 0,557 0,063 0,421
Legenda
l = taxa de chegada de pacotes na Fila
m = taxa de servico do Servidor
N = numero de pacotes simulados
T = duracao da simulacao
p = ordem dos pacotes
ic = intervalo entre chegadas de pacotes na Fila
cpf = tempo de chegada de pacote na Fila
eps = tempo de chegada de pacote no Servidor
sps = tempo de saida de pacote do Servidor
tsf = tempo total no Sistema de Fila
nf = comprimento da Fila
is = intervalo entre saidas de pacotes do Servidor
E (x) = media aritmetica de x
DP(x) = desvio padrao de x
U = utilizacao do Servidor
9.1 Sistema Cliente/Servidor Web em uma Camada Física
Um Sistema Cliente/Sevidor Web em uma camada física está ilustrada na Figura 9.1, 
com 3 SF, numeradas de 0 a 2, SF0, SF1 e SF2. A arquitetura desta rede está mostrada na 
Figura 9.2. É uma rede aberta com os parâmetros:
• os SF deste sistema são M/M/1
• sequência dos pacotes: 0 → 1, 1 → 2, 2 →1 e 1→ 0, r = [ 0, 1, 2, 1, 0 ]
• número de pacotes, N (definido pelo usuário)
• l 
• m = [ m0, m1, m2 ]
Figura 9.1 Sistema Cliente/Servidor Web em uma camada física composta por um Firewall (F), 
um Switch (S) e um Servidor Swab (Web, Aplicação e Banco de Dados).
Modelagem e Simulação Discreta 126
Figura 9.2 A arquitetura do Sistema Cliente/Servidor Web da Figura 9.1.
Em resumo, os parâmetros da RSF da Figura 9.10, para simulação de 5000 pacotes são: 
r = [ 0, 1, 2, 1, 0 ], N = 5000, l, m = [m0, m1, m2]. Os valores de l e m devem ser fornecidos 
pelo usuário.
Exemplo 9.1 Considere a rede abaixo com demanda de 5 milhões de pacotes por hora, 
considere pacotes de 2 MB.
Figura 9.3 Sistema Cliente/Servidor Web do Exemplo 9.2.
Componente n Modelo Vazão
F 0 Sophos XG 21031 29 Gbps
S 1 US-16-150W32 36 Gbps
Swad 2 HPE ProLiant ML110 – E5-2620v433 8,0 GT/s
São 3 SF com r = [0, 1, 2, 1, 0]. Com uma demanda de 5 milhões de pacotes por hora, tem-
se l = 5E6/3600 = 1388,8.
Cálculo de m = [m0, m1,m2] para pacotes de 2 MB:
m0=29Gbps=29×109 b×pacote
s×pacote
=29×109 pacote×b
2×106×8b s
=1812,5 pps
m1=36Gbps=36×109 b×pacote
s×pacote
=36×109 pacote×b
2×106×8b s
=2250 pps
m2=8GBps=8×109 B×pacote
s×pacote
=8×109 pacote×B
2×106×Bs
=4000 pps
Logo m = [1812.5, 2250, 4000].
Os parâmetros desta RSF, para uma simulação de 5000 pacotes são:
r = [0, 1, 2, 1, 0], N = 5000, l = 1388.8 e m = [1812.5, 2250, 4000].
Resumo dos Indicadores por SF obtidos pelo RSF.MM1.cpp:
SF T N E[tsf] E[nf] U
0 7,18 10000 0 3,63 0,78
1 7,08 10000 0 2,53 0,62
2 3,38 5000 0 0,68 0,38
31 https://www.sophos.com/en-us/medialibrary/PDFs/factsheets/sophos-xg-series-appliances-brna.pdf
32 Fonte: https://dl.ubnt.com/datasheets/unifi/UniFi_PoE_Switch.pdf
33 Fonte: https://support.hpe.com/hpesc/public/docDisplay?docId=emr_na-c04617738
Modelagem e Simulação Discreta 127
Os resultados da simulação que os equipamentos estão adequados para o projeto, com 
certa ociosidade do servidor (Swab), podendo ser substituído por outro de vazão um pouco 
menor. 
9.2 Sistema Cliente/Servidor Web em duas Camadas Físicas
Um Sistema Cliente/Sevidor Web em duas camadas físicas é ilustrada na Figura 9.4, com 
4 SF, numeradas de 0 a 3, SF0, SF1, SF2 e SF3. A arquitetura desta rede está mostrada na 
Figura 9.5. É uma rede com os parâmetros:
• os SF deste sistema são M/M/1
• sequência dos pacotes: 0 → 1, 1 → 2, 2 → 1, 1 → 3, 3 → 1, 1 → 2, 2 → 1, 1 → 0, r = [ 0, 1, 
2, 1, 3, 1, 2, 1, 0 ]
• número de pacotes, N (definido pelo usuário)
• l
• m = [ m0, m1, m2, m3 ]
Figura 9.4 Sistema Cliente/Servidor Web em duas camadas físicas compostas por um Firewall 
(F), um Switch (S), um Servidor Web (Sw) e um Servidor Sab (Aplicação e Banco de Dados).
Figura 9.5 A arquitetura do Sistema Cliente/Servidor Web da Figura 9.4.
Modelagem e Simulação Discreta 128
Em resumo, os parâmetros da RSF da Figura 9.12, para simulação de 5000 pacotes são: 
r = [ 0, 1, 2, 1, 3, 1, 2, 1, 0 ], N = 5000, l, m = [m0, m1, m2, m3]. Os valores de l e m devem 
ser fornecidos pelo usuário.
Exemplo 9.2 Considere a rede abaixo com demanda de 5 milhões de pacotes por hora, 
considere pacotes de 2 MB.
Figura 9.6 Sistema Cliente/Servidor Web do Exemplo 9.3.
Componente n Modelo Vazão
F 0 Sophos XG 21034 29 Gbps
S 1 US-16-150W35 36 Gbps
Sw 2 Apache HTTP Server 2.436 7500 req/s
Sad 3 HPE ProLiant ML110 – E5-2620v437 8,0 GT/s
São 3 SF com r = [0, 1, 2, 1, 3, 1, 2, 1, 0]. Com uma demanda de 5 milhões de pacotes por 
hora, tem-se l = 5E6/3600 = 1388,8.
O Servidor Web Apache HTTP Server 2.4 deve ser instalado em um Hardware com CPU de 16 núcleos, cada 
núcleo processando 108 req/s38.
Logo m = [1812.5, 2250, 7500, 4000].
Os parâmetros desta RSF, para uma simulação de 5000 pacotes são:
r = [0, 1, 2, 1, 3, 1, 2, 1, 0], N = 5000, l = 1388.8 e m = [1812.5, 2250, 7500, 4000].
Resumo dos Indicadores por SF obtidos pelo RSF.MM1.cpp:
SF T N E[tsf] E[nf] U
0 7,33 10000 0 3,02 0,76
1 14,62 20000 0 3,78 0,61
2 7,08 10000 0 0,25 0,19
3 3,23 5000 0 0,66 0,38
Os resultados da simulação que os equipamentos estão adequados para o projeto, com certa 
ociosidade dos servidores Sw e Sab.
9.3 Sistema Cliente/Servidor Web em três Camadas Físicas
34 Fonte: https://www.sophos.com/en-us/medialibrary/PDFs/factsheets/sophos-xg-series-appliances-brna.pdf
35 Fonte: https://dl.ubnt.com/datasheets/unifi/UniFi_PoE_Switch.pdf
36 Fonte: https://documentation.commvault.com/commvault/v11/article?p=1662.htm
37 Fonte: https://support.hpe.com/hpesc/public/docDisplay?docId=emr_na-c04617738
38 Fonte: https://serverguy.com/comparison/apache-vs-nginx/
Modelagem e Simulação Discreta 129
Um Sistema Cliente/Servidor Web em três camadas físicas é ilustrada na Figura 9.7, com 
5 SF, numeradas de 0 a 4, SF0, SF1, SF2, SF3 e SF4. A arquitetura desta rede está mostrada 
na Figura 9.8. É uma rede com os parâmetros:
• os SF deste sistema são M/M/1
• sequência dos pacotes:
• 0 → 1, 1 → 2, 2 → 1, 1 → 3, 3 → 1, 1 → 4, 4 → 1, 1 → 3, 3 → 1, 1 → 2, 2 → 1, 1 → 0, r = [ 0, 
1, 2, 1, 3, 1, 4, 1, 3, 1, 2, 1, 0 ]
• número de pacotes, N (definido pelo usuário)
• l 
• m = [ m0, m1, m2, m3, m4 ]
Figura 9.7 Sistema Cliente/Servidor Web em três camadas físicas compostas por um Firewall 
(F), um Switch (S), um Servidor Web (Sw), um Servidor de Aplicação (Sa) e um Servidor de 
Banco de Dados (Sd).
Figura 9.8 A arquitetura do Sistema Cliente/Servidor Web da Figura 9.7.
Em resumo, os parâmetros da RSF da Figura 9.9, para simulação de 5000 pacotes são: r 
= [ 0, 1, 2, 1, 3, 1, 4, 1, 3, 1, 2, 1, 0 ], N = 5000, l, m = [m0, m1, m2, m3, m4]. Os valores de 
l e m devem ser fornecidos pelo usuário.
Modelagem e Simulação Discreta 130
Exemplo 9.3 Considere a rede abaixo com demanda de 5 milhões de pacotes por hora, 
considere pacotes de 2 MB.
Figura 9.9 Sistema Cliente/Servidor Web de três camadas.
Component
e
n Modelo Vazão
F 0 Sophos XG 21039 29 Gbps
S 1 US-16-150W40 36 Gbps
Sw 2 Apache HTTP Server 2.441 7500 req/s
Sa 3
HPE ProLiant ML110 – E5-
2620v442 8,0 GT/s
Sd 4 MariaDB 10.5.543 20 Ktps
https://mariadb.com/resources/blog/benchmark-mariadb-vs-mysql-on-commodity-cloud-hardware/
São 3 SF com r = [ 0, 1, 2, 1, 3, 1, 4, 1, 3, 1, 2, 1, 0 ]. Com uma demanda de 5 milhões de 
pacotes por hora, tem-se l = 5E6/3600 = 1388,8.
O Servidor Web Apache HTTP Server 2.4 deve ser instalado em um Hardware com CPU de 16 núcleos, cada 
núcleo processando 108 req/s44.
Logo m = [1812.5, 2250, 7500, 4000, 20000].
Os parâmetros desta RSF, para uma simulação de 5000 pacotes são:
r = [ 0, 1, 2, 1, 3, 1, 4, 1, 3, 1, 2, 1, 0 ]], N = 5000, l = 1388.8 e m = [1812.5, 2250, 7500, 
4000, 20000].
Resumo dos Indicadores por SF obtidos pelo RSF.MM1.cpp:
SF T N E[tsf] E[nf] U
0 7,09 10000 0 3,24 0,76
1 17,81 25000 0 4,92 0,63
2 6,9 10000 0 0,27 0,19
3 3,18 5000 0 0,75 0,39
4 3,18 5000 0 0,09 0,08
Os resultados da simulação que os equipamentos estão adequados para o projeto, com certa 
ociosidade dos servidores Sw, Sa e Sb. 
39 Fonte: https://www.sophos.com/en-us/medialibrary/PDFs/factsheets/sophos-xg-series-appliances-brna.pdf
40 Fonte: https://dl.ubnt.com/datasheets/unifi/UniFi_PoE_Switch.pdf
41 Fonte: https://documentation.commvault.com/commvault/v11/article?p=1662.htm
42 Fonte: https://support.hpe.com/hpesc/public/docDisplay?docId=emr_na-c04617738
43 Fonte: https://mariadb.com/resources/blog/benchmark-mariadb-vs-mysql-on-commodity-cloud-hardware/
44 Fonte: https://serverguy.com/comparison/apache-vs-nginx/
Modelagem e Simulação Discreta 131
Exemplo 9.4 Considere a rede abaixo com demanda de 5 milhões de pacotes por hora, 
considere pacotes de 200 KB.
Figura 9.10 Sistema Cliente/Servidor Web da Figura 9.9.
Component
e
n Modelo Desempenho (ts)
S 0 Cisco Catalyst 2960-CX 12 Gbps
Sw 1 Apache 2.4.1 108 req/s
Sad 2 MySQL 5.7 25 KTps
São 3 SF com r = [0, 1, 0, 2, 0, 1, 0]. Com uma demanda de 5 milhões de pacotes por hora, 
tem-se l = 5E6/3600 = 1388,89 pacotes por segundo ou l = 1389 pps.
Cálculo de ts0 para o pacote de 200 KB:
m0=12Gbps=12×109 b×pacote
s×pacote
=12×109 pacote×b
200 x1024×8b s
=7324 pacotes / s 
Logo m = [7324, 108, 25000].
Os parâmetros desta RSF, para uma simulação de 5000 pacotes são:
r = [0, 1, 0, 2, 0, 1, 0], N = 5000, l = 1389 e m = [7324, 108, 25000].
9.4 Simulação de Sistemas de Hardware
A simulação sistema de hardware mostrado na Figura 9.11 é complexa e extrapola o 
nível deste texto mas pode-se simular partes do mesmo e avaliar seu comportamento. 
Tomando uma parte desta arquitetura, como mostrado na Figura 9.12. (Sun Microsystems, 
2016).
Modelagem e Simulação Discreta 132
Figura 9.11 Diagrama de blocos de parte do Sun Fire X4150 (Sun Microsystems, 2016).
Uma alternativa simples é considerar que dados chegam da memória por meio da ponte 
norte (MCH) e são processados na CPU. Neste caso, pode-se considerar a MCH como a Fila e 
a CPU como o Servidor, Figura 9.12, tem-se então uma rede aberta com os parâmetros:
• o SF é M/M/1
• número de pacotes, N (definido pelousuário)
• l
• m = [m0 ]
Figura 9.12 Modelo de um Sistema de Fila da Figura 9.11.
Modelagem e Simulação Discreta 133
9.5 Revisão
9.6 Exercícios
1. Simule os exemplos deste capítulo com o software RSF.MM1.cpp e calcule:
a) o tempo de simulação
b) os maiores valores de nf de cada componente
2. Simule os exemplos deste capítulo com o software RSF.MM1 e, considerando os valores 
de ts de maior desempenho, calcule:
a) o tempo de simulação
b) os maiores valores de nf de cada componente
3. Compare os resultados dos exercícios 1 e 2.
Modelagem e Simulação Discreta 134
10 GERAÇÃO DE NÚMEROS ALEATÓRIOS
Desde que, em 1859, Darwin e Maxwell introduziram a incerteza, a aleatoriedade e o 
acaso como elementos explicativos nas ciências, esses agentes imprevisíveis se revelaram 
atuantes em todos os domínios da Natureza, da vida e invadiu as ciências.
Uma maneira de usar esta propriedade dos sistemas é fazer uso de números aleatórios. 
Em estatística, um número aleatório é um número que pertence a uma série numérica e que 
não pode ser previsto a partir dos seus membros anteriores (Jain,1991).
Gerador de Números Pseudoaleatórios (PRNG – PseudoRandom Number Generator), 
também conhecido como gerador de bits aleatórios determinísticos (DRBG – Deterministic 
Random Bit Generator), são algoritmos para gerar sequências de números cujas propriedades 
se aproximam das propriedades das sequências de números aleatórios. A sequência gerada 
por um Gerador de Números Pseudo-Aleatório (GNPA) – doravante GNA – não é 
verdadeiramente aleatória, porque é determinada por um valor inicial, chamado de semente 
do gerador.
A abordagem preferida para a geração de números aleatórios em computadores envolve 
a utilização de fórmulas de recorrência que podem ser implementadas de forma simples e 
rápida. Os elementos de uma série de números pseudoaleatórios45, para aplicação em 
simulações, quer sejam bits ou números, devem ter as propriedades:
• uniformemente distribuídos
• estatisticamente independente
• não repetição para um comprimento desejado
• reprodutível
• rápida obtenção de modo a poupar recursos computacionais para as simulações em si
45 A denominação número aleatório neste texto refere-se, em geral, a número pseudoaleatório. Algoritmos geram apenas números 
pseudoaleatórios. O sítio www.random.org trata deste assunto extensivamente.
Modelagem e Simulação Discreta 135
Os primeiros GNAs desenvolvidos foram os Geradores Congruentes Lineares (GCL) 
proposto por D. H. Lehmer em 1949. Uma lista completa dos GNAs pode ser obtida 
pesquisando overbete “List of random number generators” na Wikipedia.
10.1 Geradores Congruentes Lineares (GCL)
A expressão geral do Gerador Congruente Linear (GCL) é xn = f(xn-1). O GCL expressa 
pela Equação 10.1 (Hull & Dobell, 1962) é uma relação recursiva constituída por três valores 
constantes ( a, c, m ∊ ℕ; a – constante multiplicadora, c – incremento e m – módulo) e a 
semente x1.
x i=(a xi−1+c)modm 10.1
 A partir de x1 são calculados sucessivamente os valores de x2, x3, x4, …, xm.
É necessário que x1 ≠ x2 ≠ x3 ≠ … ≠ xm, ou seja, não tenha repetição na sequência 
gerada. Entretanto, a existência de ciclos é comum nestas sequências.
Os parâmetros a, c e m do GCL afetam a média, a variância e a duração do ciclo das 
sequências (sequência sem repetição). Para produzir séries de números aleatórios com 
período máximo, ciclo de tamanho igual a m-1, deve-se selecionar os valores de a, c e m 
conforme estabelece o Teorema de Hull-Dobell (Hull & Dobell, 1962), a saber:
Teorema de Hull-Dobell: O método congruente linear tem período m-1 se, e somente se, 
as seguintes três condições são válidas (Hull & Dobell, 1962):
1. c e m são primos entre si, mdc(c,m) = 1
2. (a-1) é múltiplo de q, para todo fator primo q de m
3. se m é múltiplo de 4 então (a-1) é múltiplo de 4
Bandyopadhyay e Bhattacharya (2014) estabeleceu outros critérios para os parâmetros 
a, c e m, descritos a seguir:
1. se m = 2b e c ≠ 0 então o comprimento máximo do ciclo será igual a m para c e m 
primos entre si e também a e m primos entre si com a = 1+4k, k inteiro.
2. se m = 2b e c = 0 então o comprimento máximo do ciclo será igual a 2b-2 com a = 3+8k 
ou a = 5+8k, k inteiro.
3. se m é um número primo e c = 0 então o comprimento máximo do ciclo será igual a m-
1 com ak-1 divisível por m, onde k = m–1.
Modelagem e Simulação Discreta 136
Utilizando os critérios de Bandyopadhyay e Bhattacharya pode-se produzir séries de 
números aleatórios de tamanhos variados e com período máximo.
Exemplo 10.1 A série gerada a partir de xn = (75 xn-1) % (231-1), com m = 231-1, a = 75 e c = 
0, que seguem as condições do Teorema de Hull-Dobell, tem um ciclo igual 231-1, 
aproximadamente uma sequência de 2,1×109 números sem repetição, suficientemente 
grande para simulações de Redes de Sistemas de Fila46.
Exemplo 10.2 A série gerada a partir de xn = (11 xn-1) % 252, com m = 2b, a = 3+8k e c = 0, 
para b = 52 e k = 1, seguem os critérios de Bandyopadhyay e Bhattacharya, tem um ciclo 
igual 250, aproximadamente uma sequência de 1,1×10¹⁵ números sem repetição, 
suficientemente grande para simulações de Redes de Sistemas de Fila.
10.2 Aplicação do GCL
A aplicação imediata dos GCLs é a geração de distribuições uniformes contínuas, U(0,1). 
A função un=xn/m, un ∊ [0,1) e U = {un}.
Exemplo 10.3 A sequência xi = 6xi-1 + 5 mod 11 tem período igual a 11. Para x1 = 0, a 
sequência gerada é { 0, 5, 2, 6, 8, 9, 4, 7, 3, 1 }. Dividindo estes valores por 11, obtêm-se 
U = { 0,0000 0,4545 0,1818 0,5455 0,7273 0,8182 0,3636 0,6364 0,2727 0,0909 }.
Uma observação importante sobre este exemplo é que a função xn é determinística. Dada a 
semente, podemos predizer, com certeza, os números da sequência. No entanto, os 
números são aleatórios no sentido de que eles passariam por testes estatísticos para 
aleatoriedade.
Os exemplos abaixo discutem a estrutura das sequências geradas por um GCL, suas 
conclusões se aplicam a qualquer GCL que atende o Teorema de Hull-Dobell.
Exemplo 10.4 A sequência xi = 5xi-1 + 3 mod 8 tem período igual a 8. Na tabela abaixo estão 
os números aleatórios gerados por esta sequência para vários valores de x1.
Números aleatórios gerados a partir de xi = 5xi-1 + 3 mod 8 para x1 = 0, 1, …, 7 (semente)
46 Números Aleatórios tem aplicações em diversas áreas, como jogos e criptopgrafia, cada uma delas tem seus GNAs adequados aos seus 
propósitos. O GCL atende amplamente a simulação dos Sistemas Computacionais aqui estudados.
Modelagem e Simulação Discreta 137
x0 0 1 2 3 4 5 6 7
x1 3 0 5 2 7 4 1 6
x2 2 3 4 5 6 7 0 1
x3 5 2 7 4 1 6 3 0
x4 4 5 6 7 0 1 2 3
x5 7 4 1 6 3 0 5 2
x6 6 7 0 1 2 3 4 5
x7 1 6 3 0 5 2 7 4
Na tabala acima, as sequências geradas são as colunas, a linha coluna correspondente a x1 é 
a semente utilizada para gerar a coluna de números aleatórios. A análise dos valores gerados 
apresentados nesta tabela permitem as seguintes conclusões:
• as sequências geradas têm os mesmos valores, são os números de 0 a 7, o que muda é 
a ordem destes números em cada sequência (coluna) gerada47
• a semente x1 determina a ordem da sequência
• m determina a quantidade de valores gerados no ciclo
• o ciclo deste gerador é igual a 8 (m) e sua sequência é { x0, x1, x2, x3, x4, x5, x6, x, x7 }
• a soma do ciclo gerado é igual a 28, generalizando, m(m-1)/2 
Nota: denomina-se GCL misto se c = 0 e GCL multiplicativo se c ≠ 0.
Exemplo 10.5 A sequência xi = 5xi-1 + 3 mod 8 tem período igual a 8. Na tabela abaixo estão 
os números aleatórios gerados por esta sequência para vários valores de x1. Em linhas e 
colunas duplicadas.
Números aleatórios gerados a partir de xi = 5xi-1 + 3 mod 8 para x1 = 0, 1, …, 7 (semente)
x1 0 1 2 3 4 5 6 7 0 1 2 3 4 5 6 7
x2 3 0 5 2 7 4 1 6 3 0 5 2 7 4 1 6
x3 2 3 4 5 6 7 0 1 2 3 4 5 6 7 0 1
x4 5 2 7 4 1 6 3 0 5 2 7 4 1 6 3 0
x5 4 5 6 7 0 1 2 3 4 5 6 7 01 2 3
x6 7 4 1 6 3 0 5 2 7 4 1 6 3 0 5 2
x7 6 7 0 1 2 3 4 5 6 7 0 1 2 3 4 5
x8 1 6 3 0 5 2 7 4 1 6 3 0 5 2 7 4
x9 0 1 2 3 4 5 6 7 0 1 2 3 4 5 6 7
x10 3 0 5 2 7 4 1 6 3 0 5 2 7 4 1 6
x11 2 3 4 5 6 7 0 1 2 3 4 5 6 7 0 1
47 Um GCL gera uma única série aleatória e, ao variar a semente, pode-se acessar diferentes sequências desta série.
Modelagem e Simulação Discreta 138
x12 5 2 7 4 1 6 3 0 5 2 7 4 1 6 3 0
x13 4 5 6 7 0 1 2 3 4 5 6 7 0 1 2 3
x14 7 4 1 6 3 0 5 2 7 4 1 6 3 0 5 2
x15 6 7 0 1 2 3 4 5 6 7 0 1 2 3 4 5
x16 1 6 3 0 5 2 7 4 1 6 3 0 5 2 7 4
Na tabela acima, as sequências geradas são as colunas, a linha coluna correspondente a x1 é 
a semente utilizada para gerar a coluna de números aleatórios. A análise dos valores gerados 
apresentados nesta tabela permitem as seguintes conclusões:
• as sequências geradas têm os mesmos valores, são os números de 0 a 7, o que muda é 
a ordem destes números em cada sequência (coluna) gerada
• a semente x0 determina a ordem da sequência
• m determina a quantidade de valores gerados no ciclo,
• o ciclo deste gerador é igual a 8 (m) e sua sequência é { x1, x2, x3, …, x8 }
• a partir de x9 a sequência é reiniciada, e o novo ciclo é igual ao ciclo anterior, ou seja, 
x9 = x1, x10 = x2, …, x15 = x7, x16 = x1, e assim por diante
• para x1 = x9 = x17 = … = xkm+1, k = 1, 2, 3, …
• para xkm+1, k = 1, 2, 3, …, a sequência gerada é reiniciada
10.3 Sementes para o GCL
Como foi destacado, a semente x0 é o primeiro valor de uma sequência dos GCLs e, para 
gerar as diferentes sequências do mesmo GCL, bastar fazer variar suas sementes. Logo, a 
seleção adequada da semente se reveste de grande importância.
A técnica de associar o valor da semente ao momento atual é capaz de gerar as 
diferentes sequências de um GCL. Esta técnica, que usa a medição do tempo, gera sementes 
adequadas para os GNA, uma vez que o tempo é uma grandeza que cresce continuamente.
A linguagem C, por exemplo, possui a função time(nullptr) que obtém o número de 
segundos transcorridos desde 01/01/1970 00:00:00.
10.4 GCL de uso geral
No Quadro 10.1 estão alguns métodos dos GNA GCL. Estes GCL possuem período 
máximo igual a m.
Pode-se destacar neste quadro o GCC, utilizado na linguagem de programação C/C++, 
ele é um GCL misto com a recorrência dada pela fórmula: xn+1 = (1103515245 xn+12345) 
Modelagem e Simulação Discreta 139
mod 231, que é capaz de produzir uma sequência de números inteiros no conjunto { 0, 1, 2, 3, 
…, 231= 2147483648 ≈ 2,1×109}.
Da mesma forma, o GCL MMIX de 64 b com um ciclo de 1,8x1019 e também o GCL Posix 
de 48 b com um ciclo de 2,8×1014.
Quadro 10.1 Geradores de números aleatórios adequados à simulação de RSF
Fonte m a c
Borland C++ 232 22695477 1
GCC 231 1103515245 12345
Posix 248 25214903917 11
Microsoft Visual Basic 224 1140671485 12820163
Microsoft Visual C++ 232 214013 2531011
MMIX 264 6364136223846793005 1442695040888963407
Numerical Recipes 232 1664525 1013904223
RANDU 231 65539 0
VAX 231 69069 1
10.5 Números Aleatórios do GNU C
A linguagem C (GNU GCC e G++) possui duas funções e uma constante para gerar 
números aleatórios com seu GCL (Quadro 10.2), a saber:
Quadro 10.2 As funções, a constante e as bibliotecas da linguagem C para gerar números 
aleatórios
Recurso Descrição
RAND_MAX constante inteira definida no arquivo stdlib.h
void srand(unsigned) atribui semente ao CGL, em geral srand(time(0))
int rand(void) retorna um número pseudoaleatório com valor em [0, RAND_MAX]
stdlib.h, time.h bibliotecas da linguagem C
O Programa 10.1 gera números pseudoaleatórios com valor em [0,RAND_MAX] tendo 
como semente time(0) - número de segundos decorridos desde 01/01/1970 00:00:00 UTC.
Programa 10.1 Programa em C para gerar números pseudoaleatórios com valor em 
[0,RAND_MAX]
#include <stdlib.h>
Modelagem e Simulação Discreta 140
#include <time.h>
long gna( void ){
 return rand();
}
int main( void ){
 srand(time(nullptr));
 printf( " %d ", gna() );
 return 0;
}
O Programa 10.2 gera valores da distribuição uniforme U no intervalo (0,1) tendo como 
semente time(0).
Programa 10.2 Programa em C para gerar valores da distribuição uniforme no intervalo 
(0,1)
#include <stdlib.h>
#include <time.h>
double u( void ){
 return (rand()+1.0)/(RAND_MAX+2.0); // intervalo (0,1)
}
int main( void ){
 srand(time(nullptr));
 printf( " %f ", u() );
 return 0;
}
Na biblioteca GNU Scientific Library (https://www.gnu.org/software/gsl/doc/html/) pode-se 
encontrar vários GCL.
Use a Equação 10.2 para gerar valores da distribuição uniforme U no intervalo [0,1].
rand ( )
RANDMAX
∈[0,1] 10.2
Use a Equação 10.3 para gerar valores de U no intervalo (0,1).
rand ( )+1
RANDMAX+2
∈(0,1) 10.3
Use a Equação 10.4 para gerar valores de U no intervalo [a,b], para u ∊ [0,1].
a+(b−a)u 10.4
Use a Equação 10.5 para gerar valores de U no (a,b), para v ∊ (0,1).
Modelagem e Simulação Discreta 141
a+(b−a)v 10.5
10.6 Composição de Geradores
A combinação de geradores resulta numa sequências de valores com melhores 
propriedades estatísticas e com períodos mais longos em comparação com aqueles gerados 
a partir de um único gerador. Um exemplo é o gerador Zn apresentado abaixo, que combina 
dois GCLs, An e Bn:
An=(a0 An−1+a1 An−2)mod ma
Bn=(b0Bn−1+b1Bn−2)modmb
Zn=(An+Bn)modm
10.6
Uma rica fonte de GNA é a “GNU Scientific Library”, seu manual está disponível em 
https://www.gnu.org/software/gsl/doc/html/. O exemplo abaixo foi extraído deste documento.
Exemplo 10.6 zn é um outro gerador recursivo combinado de L’Ecuyer, ele combina dois 
geradores recursivos e tem período igual a 2185 (4,9×1055):
zn=(xn− yn)mod m1
xn=(a1 xn−1+a2 xn−2+a3 xn−3)modm1
yn=(b1 yn−1+b2 yn−2+b3 y n−3)modm2
em que a1 = 0, a2 = 63308, a3 = −183326, b1 = 86098,
b2 = 0, b3 = −539608, m1 = 2147483647 e m2 = 2145483479.
Fonte: GNU Scientific Library, Release 2.6. 2019 (https://www.gnu.org/software/gsl/doc/html/).
Exemplo 10.7 O gerador recursivo combinado L’Ecuyer's, referido como MRG32k3a 
(L’Ecuyer, 2020), combina dois geradores recursivos e tem período igual a 2191 (3,1×1057), 
suficientemente longo para a maioria das simulações senão para todas elas (L’Ecuyer's, 
2007):
xi = ( a1 xi-1 + a2 xi-2 + a3 xi-3 ) mod m1
yi = ( b1 yi-1 + b2 yi-2 + b3 yi-3 ) mod m2
zi = ( xi-yi ) mod m1
ui = zi/m1
em que:
a1 = 0, a2 = 1403580, a3 = 810728, m1 = 232-209,
b1 = 527612, b2 = 0, b3 = 1370589 e m2 = 232-22853,
https://www.gnu.org/software/gsl/doc/html/
Modelagem e Simulação Discreta 142
zi, i = 1, 2, … é a sequência de números pseudoaleatórios,
ui, i = 1, 2, … é a distribuição uniforme desejada
Programa 10.3 Programa C do gerador recursivo combinado MRG32k3a, adaptado de 
(L’Ecuyer, 2020)
// MRG32k3a: 32-bits Random number generator U(0,1)
// Author : Pierre L'Ecuyer,
// Source : Good Parameter Sets for Combined Multiple Recursive Random Number Generators,
// Shorter version in Operations Research, 47, 1 (1999), 159–164.
#include <stdio.h>
#include <stdlib.h>
#include <time.h>
#define norm 2.328306549295728e-10
#define m1 4294967087.0
#define m2 4294944443.0
#define a12 1403580.0
#define a13n 810728.0
#define a21 527612.0
#define a23n 1370589.0
// The seeds for s10, s11, s12 must be integers in [0, m1-1] and not all 0.
// The seeds for s20, s21, s22 must be integers in [0, m2-1] and not all 0.
long s10, s11, s12, s20, s21, s22;
int gna( void ){
 return rand(); // intervao [0,RAND_MAX]
}
double MRG32k3a(void){
 long k;
 double p1, p2;
 p1 = a12 * s11 - a13n * s10; // Component 1
 k = p1 / m1;
 p1 -= k * m1;
 if( p1 < 0.0 ) p1 += m1;
 s10 = s11;
 s11 = s12;
 s12 = p1;
 p2 = a21 * s22 - a23n * s20; // Component 2
 k = p2 / m2;
 p2 -= k * m2;
 if( p2 < 0.0 ) p2 += m2;
 s20 = s21;
 s21 = s22;
 s22 = p2;
Modelagem e Simulação Discreta 143
 printf( "%11ld %11ld %11ld :: ", s10, s11, s12);
 printf( "%11ld %11ld %11ld >> ", s20, s21, s22);return norm*( p1 <= p2 ? p1-p2+m1 : p1-p2 ); // Combination
}
int main( void ){
 int i;
 srand(time(0));
 s10 = gna(), s11 = gna(), s12 = gna(),
 s20 = gna(), s21 = gna(), s22 = gna();
 for( i = 0; i < 20; i++ )
 printf( "%.22lf\n", MRG32k3a() );
 return 0;
}
10.7 Geradores Tausworthe
Os geradores Tausworthe operam diretamente sobre bits. Uma sequência de dígitos 
binários é definida pela recorrência bi = (c1bi-1 + c2bi-2 + ··· + cqbi-q) mod 2, onde c1, …, cq são 
constantes binárias.
Neste caso, um ciclo é definido como uma sequência de valores binários que se repetem 
continuamente. Portanto, como os q bits anteriores são utilizados, o período pode chegar a 2q 
- 1. De modo geral, os geradores Tausworthe são da forma b i = (bi-r+ bi-q) mod 2 sendo r, q ∈ 
N e 0 < r < q.
10.8 Outros Geradores
O Gerador Mersenne Twister (MT) foi desenvolvido por Makoto Matsumoto e Takuji 
Nishimura. Seu ciclo é extremamente longo, com período de 219937-1 (aproximadamente 
1013819), com sequência iid. Seu código em C está disponível no arquivo mt19937.c (Mersenne 
Twister, 2011). Este gerador já está disponível em C++ na sua biblioteca random. 
A API Math.random(), escrita em JavaScript, utiliza o GNA Xoroshiro128+ gera números 
no intevalor [0,1), este GNA se baseia no Gerador MT.
Modelagem e Simulação Discreta 144
10.9 Classe clGNA
A classe clGNA escrita em Javascript está descrita no Programa 10.4. Nesta classe a 
semente (x0) é obtida do tempo do navegador, dado em milissegundos desde 01/01/1970. 
Por exemplo, para a data 18/09/2022 16:24:21 a semente é igual a 1663529061412.
Nesta classe, o valor de m é 231-1, mas pode-se adaptar a classe para outros valores de 
m. O valor de x0 é corrigido se x0 > m e se x0 < 0. A função setX0 é executada quando se 
instância um objeto da classe. As funções gna, gna1, gna2, …, gna7, geram números 
aleatórios no intervalo [0,m-1].
Programa 10.4 Classe clGNA em Javascript para os GCL’s do Quadro 10.1
function clGNA(){
 let x, m0, m1, m2, m3;
 this.ANSI = function(){ x = ( 1103515245*x+ 12345)%m0; return (x/m0); }
 this.Apple = function(){ x = ( 16807*x )%m1; return (x/m1); }
 this.BorC = function(){ x = ( 22695477*x+ 1)%m2; return (x/m2); }
 this.BorD = function(){ x = ( 134775813*x+ 1)%m2; return (x/m2); }
 this.C11 = function(){ x = ( 48271*x )%m1; return (x/m1); }
 this.cc65 = function(){ x = ( 16843009*x+ 826366247)%m2; return (x/m2); }
 this.GCC = function(){ x = ( 1103515245*x+ 12345)%m0; return (x/m0); }
 this.glibc = function(){ x = ( 1103515245*x+ 12345)%m0; return (x/m0); }
 this.Java = function(){ x = (25214903917*x+ 11)%m3; return (x/m3); }
 this.MVC = function(){ x = ( 214013*x+ 2531011)%m2; return (x/m2); }
 this.NR = function(){ x = ( 1664525*x+1013904223)%m2; return (x/m2); }
 this.Posix = function(){ x = (25214903917*x+ 11)%m3; return (x/m3); }
 this.Randu = function(){ x = ( 65539*x )%m0; return (x/m0); }
 this.Rtl = function(){ x = ( 2147483629*x+2147483587)%m1; return (x/m1); }
 this.Vax = function(){ x = ( 69069*x+ 1)%m0; return (x/m0); }
 this.VMS = function(){ x = ( 69069*x+ 1)%m2; return (x/m2); }
 this.Javascript = function(){ return Math.random(); }
 this.setX0 = function(){
 x = (new Date()).getTime();
 m0 = 2147483648, //Math.pow(2,31)
 m1 = 2147483647, //Math.pow(2,31)-1
 m2 = 4294967296, //Math.pow(2,32)
 m3 = 281474976710656; //Math.pow(2,48)
 if( x > m1 ) x = x % m1;
 }
 this.setX0();
}
O Exemplo 10.9 é um programa em C++ para gerar números aleatórios Apple 
CarbonLib, conforme a descrito no Quadro 10.1. Os demais GCL deste quadro podem ter 
programas semelhantes ao exemplo abaixo.
Exemplo 10.8 Programa em C++ para gerar números aleatórios Apple CarbonLib.
O GNA Apple CarbonLib tem m = 231-1, a = 16807 e c = 0, a função gnacl abaixo gera dados deste GNA com 
semente obtida do tempo do sistema.
O software abaixo gera 10 números aleatórios Apple CarbonLib.
#include <iostream>
#include <cmath>
Modelagem e Simulação Discreta 145
#include <ctime>
using namespace std;
long gnacl( void ){
 static long x = time(NULL),
 m = pow(2,31)-1;
 x = (16807*x)%m;
 return x;
}
int main( void ){
 for( int i = 0; i < 10; i++ )
 cout << gnacl() << endl;
 return 0;
}
10.10 Teste Empíricos de GNA
É uma boa prática verificar estatisticamente os valores de um gerador de números 
pseudoaleatório antes de usá-lo. O comportamento estatístico de um gerador de números 
aleatórios pode ser influenciado pela sua implementação em uma linguagem de 
programação bem como pelo hardware utilizado. Existe uma grande variedade de testes para 
sequências de números aleatórios, como os seguintes testes estatísticos:
• Teste de frequência
• Teste de serial
• Teste de autocorrelação
• Teste runs
• Teste de Chi-Quadrado
Também existe muita controvérsia sobre quais são os melhores, se testes teóricos são 
mais definitivos que os empíricos. Se a amostra utilizada em um teste empírico for muito 
pequena, o resultado pode corresponder apenas a um pequeno fragmento do ciclo. Por outro 
lado, um teste que leva em conta um ciclo inteiro pode não ser compatível com fragmentos 
deste mesmo ciclo.
Modelagem e Simulação Discreta 146
Nenhuma quantidade de testes pode determinar que um gerador é o melhor em todos 
os casos. Portanto, a recomendação é que os testes sejam consistentes com o uso que será 
dado ao gerador. Se os números serão utilizados aos pares, por exemplo, deve-se examinar o 
comportamento de pares e, neste caso, talvez com um teste serial seja o mais apropriado.
Assim, deve-se escolher com cuidado o teste do gerador se a simulação é onerosa, 
requer alta precisão ou é um componente crítico de um estudo.
Muitos testes estatísticos úteis podem ser encontradas em NIST (2010). Os sítios a 
seguir possuem suítes para testar sequências de números aleatórios:
• Dieharder: A Random Number Test Suite 
http://www.phy.duke.edu/~rgb/General/dieharder.php
• The Marsaglia Random Number CDROM including the Diehard Battery of Tests of 
Randomness http://i.cs.hku.hk/~diehard/cdrom/
• TestU01: A C Library for Empirical Testing of Random Number Generators 
http://www.iro.umontreal.ca/~lecuyer/myftp/papers/testu01.pdf
10.10.1 Testes Empíricos
O gráfico dos pares (xi,xi+1) de números aleatórios permite avaliar a independência do 
gerador de números aleatórios. Quando números da sequência são independentes eles ficam 
dispersos aleatoriamente sem tendência, caso contrário estão próximos de uma reta. Pode-se 
notar na Figura 10.1 a falta de tendência na distribuição dos 500 pontos gerados, 
evidenciando graficamente a independência dos dados amostrados.
Figura 10.1 Gráfico de dispersão para avaliar graficamente a independência dos números 
aleatórios.
A Figura 10.1 foi gerada pelo Programa 10.5.
Programa 10.5 O gráfico dos pares de números aleatórios em Javascript
Modelagem e Simulação Discreta 147
<!doctype html>
<html>
<title>Dispersao de Numeros Aleatorios</title>
<head>
<script>
function Plot(){
 var cnv = document.getElementById("dispersao"),
 ctx = cnv.getContext("2d"),
 X = parseInt(cnv.getAttribute("width" )),
 Y = parseInt(cnv.getAttribute("height")),
 d = 8,
 N = 500,
 x = [1];
 ctx.fillStyle = "rgb(10,70,200)";
 for( var i = 1; i < N; i++ ){
 x[i] = Math.random();
 ctx.fillRect(x[i-1]*(X-d),x[i]*(Y-d),d,d);
 }
}
window.onload = Plot;
</script>
</head>
<body>
Grafico de Dispersao de Numeros Aleatorios<br><br>
<canvas id="dispersao" width="300" height="300"></canvas><br>
</body></html>
A Figura 10.2é um gráfico de barra que é útil para avaliar graficamente a independência 
e a distribuição dos números aleatórios gerados. As alturas das barras exibem poucas 
diferenças indicando que os números gerados estão bem distribuídos.
Figura 10.2 Gráficos de barra para avaliar a independência e a distribuição de números 
aleatórios.
Modelagem e Simulação Discreta 148
A Figura 10.2 foi gerada pelo Programa 10.6 escrito em Javascript, que faz uso da 
biblioteca gráfica flot (www.flotcharts.org), utilizando as bibliotecas jquery.js e jquery.flot.js.
Programa 10.6 Código Javascript para gerar gráficos de barra de números aleatórios
<!doctype html>
<html>
<title>Grafico de Barra de Numero Aleatorio</title>
<head>
<script src="jquery.js"> </script>
<script src="jquery.flot.js"></script>
<script>
function Plot(){
 var q = 10,
 n = 0,
 d = new Array(q),
 sum = new Array(q);
 for( var i = 0; i < q; i++ )
 sum[i] = 0;
 var timer = setInterval(function(){
 $(function(){
 for( var i = 0; i < q; i++ ){
 var r = Math.floor(Math.random()*q);
 sum[r]+= 1;
 d[i] = d.push([i+1,sum[r]]);
 n++;
 }
 document.getElementsByName('valor')[0].value = n;
 $.plot($("#graph"),[{data:d,bars:{ show:true,barWidth:0.3}}]);
 });
 },200);
}
window.onload = Plot;
</script>
</head>
<body>
<h3>Grafico de Barra de Gerador de Numero Aleatorio</h3>
<div id="graph" style="width: 400px; height: 400px;"></div>
<input type="text" value="0" name="valor" size="12"> 
</body></html>
10.11 Testes Teóricos
Os testes teóricos consistem em verificar se uma sequência de números aleatórios são 
uniformemente distribuídos, o que pode ser feito pelo Teste Chi-Quadrado. Se são 
estatisticamente independente, feito pela autocorrelação. Se não repetem para um 
comprimento desejado, feito pelo Teorema de Hull-Dobel. Se são reprodutível, basta ser GCL. 
E, por fim, se tem rápida obtenção, deve-se calcular o custo computacional do GNA.
Modelagem e Simulação Discreta 149
10.11.1 GNA com Distribuição Uniforme
O Teste Chi-Quadrado (CQ) pode ser usado como teste de aderência de uma sequência 
de números aleatórios à distribuição de probabilidade uniforme (DPU) com nível de 
significância α.
Para verificar se a sequência X = { x1, x2, …, xn } se ajusta à DPU, o Teste CQ requer:
• separar X em k classes de mesmo tamanho
• calcular a frequência observada Oi de cada classe, i = 1, 2, …, k
• calcular a frequência esperada Ei de cada classe, Ei = n/k (DPU), i = 1, 2, …, k
• calcular a estatística D=∑
i=1
k (Oi−Ei)
2
Ei
que tem distribuição χ2 com gl = k-1 graus de 
liberdade para a DPU
• decidir: se D < χ2(1-α;gl) não se pode rejeitar a hipótese H0 ao nível de significância α, 
caso contrário rejeita-se a hipótese H0.
A distribuição χ2 permite obter o valor de χ2(1-α,gl) com nível significância α e gl graus 
de liberdade (valor tabelado – unicaudal).
Exemplo 10.9 Foram gerados uma sequência com 140 números aleatórios, organizados em 
7 classes, descritas abaixo. Verifique se a sequência é uniformemente distribuída com 5% 
de significância.
Classe
Frequência 
(Oi)
1 35
2 20
3 30
4 15
5 10
6 10
7 20
Hipóteses a serem testadas:
• H0: a sequência de números aleatórios é uniformemente distribuída
• Ha: a sequência de números aleatórios não é uniformemente distribuída
Tamanho da amostra: n = 140
Número de classes: k = 7
Modelagem e Simulação Discreta 150
Cálculo de Ei = 140/7 = 20, i = 1, 2, …, k
i Oi Ei
1 35 20
2 20 20
3 30 20
4 15 20
5 10 20
6 10 20
7 20 20
Cálculo de D = (35-20)2/20 +(20-20)2/20 + … + (20-20)2/20 = 27,5
Regra de decisão: se, para α fixado, obtém-se D > χ2(1-α;gl) então rejeita-se a hipótese 
H0, caso contrário a hipótese H0 não pode ser rejeitada.
Valor de χ2(0,95;6) = 12,59 (valor tabelado – unicaudal)
Neste caso, χ2(0,95;6) = 12,59 e D > χ2(0,95;6), isto é, 27,5 > 12,59. Rejeita-se H0.
Conclusão: a sequência de números aleatórios não é uniformemente distribuída segundo o 
Teste de CQ com 95% de confiança.
10.11.2 GNA Estatisticamente Independente
Para verificar se uma sequência de números aleatórios são estatisticamente 
independente, pode-se usar a autocorrelação ρ(k) que informa o quanto o valor de uma 
variável aleatória é capaz de influenciar seus vizinhos à distância k, k > 0. Como os valores 
de ρ(k) variam de -1 a 1, a ausência de correlação é indicada por 0, ou seja, os números 
aleatórios da sequência analisada são estatisticamente independente.
Uma sequência com n números aleatórios têm autocorrelação ρ(k) dada pela Equação 
10.7.
ρ(k )=
Cov(X i , X i−k)
σ2
=
E [(X i−μ)(X i−k−μ)]
σ2
=
∑
i=k
n
(X i−μ)(X i−k−μ)
∑
i=1
n
(X i−μ)
2
10.7
Modelagem e Simulação Discreta 151
Exemplo 10.10 Verifique se os números aleatórios X = { 3, 2, 5, 4, 7, 6, 8 } são 
estatisticamente independente.
Para calcular ρ(1) são necessários calcular: (refazer)
• tamanho da amostra: n = 7
• média amostral: m = (3+2+5+4+7+6+8)/7 = 35/7 = 5
• numerador: [(3-5)x(2-5)+(2-5)x(5-5)+(4-5)x(4-5)+(4-5)x(7-5)+(7-5)x(6-5)+(6-5)x(8-
5)] = 9
• denominador: [(3-5)2+(2-5)2+(5-5)+(4-5)2+(7-5)2+(6-5)2+(8-5)2] = 28
• autocorrelação: ρ(1) = 9/28 = 0,32 
Conclusão: X não é estatisticamente independente.
10.11.3 Custo Computacional de GNA
O custo computacional de um GNA é o tempo necessário para gerar um elemento de sua 
sequência. Neste caso, basta dividir o tempo requerido para gerar uma sequência de 
números aleatórios pelo tamanho da sequência gerada.
10.11.4 Algoritmo para testes teóricos
O Programa 10.7, escrito em Javascript, ilustra alguns dos testes teóricos mais usuais: 
autocorrelação, teste de CQ e custo computacional.
Este algoritmo permite fazer o Teste de CQ com e significância α = 1% e amostras 
organizadas em 20 classes, para isso basta usar adequadamente as constantes:
• Número de classes para o Teste CQ: CLASSE = 20
• Tamanho da amostra para o Teste CQ: NUMERO = 1000000
• Tamanho da amostra para o Custo Computacional: CUSTO = 9000000,
• Valor tabelado de χ2(0,99;19):X19 = 36.19; CQ(1-α=0,99,gl = 19) - quando CLASSE = 20
A função Calcular gera x[N] números aleatórios e os classifica em v[CLASSE] classes. A 
função gna permite gerar números aleatórios utilizando a função Math.random(). A função 
Autocorrelacao calcula a autocorrelação de x[N] com k = 1. A função CQ faz o teste de CQ de 
v[CLASSE]. A função Custo estima o tempo médio para se gerar um milhão de números 
aleatórios.
No Firefox Browser, versão 104 (64-bits) for Linux mint, a autocorrelação obtida foi igual 
a 0,00258, indicando independência dos números gerados; o Teste de CQ foi: “a distribuição 
Modelagem e Simulação Discreta 152
do GNA é uniforme (0,00002 < 36,19) com 99% de confiança”, indicando que a sequência de 
números aleatórios gerada é iid U(0,1); e o custo unitário do GNA medido foi de 7.8×10-7 s, 
suficientemente pequeno.
Programa 10.7 Testes teóricos de números aleatórios
<!DOCTYPE>
<html>
<head>
<meta charset="UTF-8">
<meta name="author" content="Brauliro G Leal - brauliro.leal@univasf.edu.br">
<script>
let CLASSE = 20, NUMERO = 5000000, CUSTO = 13000000, X19 = 36.19; // CQ(1%, gl = 19)
function Autocorrelacao( x ){
 let k = 1, m = 0.0, num = 0.0, den = 0.0;
 for( let n = 0; n < NUMERO; n++ ){
 m += x[n];
 }
 m /= NUMERO;
 for( let n = k; n < NUMERO; n++ ){
 num += (x[n]-m)*(x[n-k]-m);
 }
 for( let n = 0; n < NUMERO; n++ ){
 den += (x[n]-m)*(x[n]-m);
 }
 return "autocorrelação = " + (num/den).toFixed(6);
}
function CQ( fo ){
 let fe = 1.0/CLASSE, D = 0.0, str = "";
 for( let n = 0; n < CLASSE; n++ ){
 D += Math.pow( fo[n] - fe, 2.0 )/fe;
 }
 if( D < X19 ) str = " CQ: Ho não pode ser rejeitada("
 + D.toFixed(8) + " < " + X19 
 + "), a distribuição é uniforme com 99% de confiança";else str = "CQ: Ho é rejeitada (" + D.toFixed(5) + " >= " + X19 
 + ") com 99% de confiança";
 return CQ;
}
function Custo(){
 let a, inicio = (new Date()).getTime(), fim;
 for( let n = 0; n < CUSTO; n++ ){
 a = Math.random();
 }
 fim = (new Date()).getTime();
 return "custo unitário = " + ((fim-inicio)/CUSTO).toExponential(4) + " s";
}
function Tabela(fo,v){
 let str = "<table border='1'><tr><th>i<th>v[i]<th>fo[i]<th>fe[i]";
 for( let i = 0; i < CLASSE; i++ ){
 str += "<tr>" 
 + "<td>" + (i+1)
 + "<td>" + v[i]
 + "<td>" + fo[i].toFixed(4)
 + "<td>" + (1.0/CLASSE).toFixed(4);
 }
 str += "</table>";
 return str;
}
function Calcular(){
 let x = [], v = [], fo = [], str = "";
 for( let i = 0; i < CLASSE; i++ ){
 v[i] = fo[i] = 0.0;
 }
 for( let n = 0; n < NUMERO; n++ ){
Modelagem e Simulação Discreta 153
 x[n] = Math.random();
 v[Math.floor(CLASSE*x[n])] += 1;
 }
 for( let i = 0; i < CLASSE; i++ ){
 fo[i] = v[i]/NUMERO;
 }
 str += "<p> " + Tabela(fo,v)
 + "<p>1. " + Autocorrelacao(x)
 + "<p>2. " + CQ(fo)
 + "<p>3. " + Custo();
 return str;
}
window.onload = function(){
 texto.innerHTML = "Testes Teóricos para Geradores de Números Aleatórios<hr>" 
 + Calcular() 
 + "<p>Conclusão: GNA estatisticamente independentes (1),"
 + " uniformemente distribuído (2) e"
 + " de baixo custo computacional (3).";
}
</script>
</head>
<body>
<div id="texto"></div>
</body>
</html>
É importante que o GNA utilizado no processo de simulação seja igualmente distribuído 
porque garante que, independente dos dados iniciais e de quem as façam ou quando as 
Modelagem e Simulação Discreta 154
façam, as simulações que o utilizarem apresentaram resultados similares. Esta é uma 
conclusão de ordem operacional, que assegura confiabilidade à simulação enquanto 
técnica e embasa seu uso e aplicações.
Devido à Lei dos Grandes Números, poucos dados gerados por um GNA são mal 
distribuídos. Porém, ao gerar grandes quantidades de dados por meio de um GNA, pode-se 
observar que tendem a serem igualmente distribuídos.
Daí surge uma pergunta, quantos pacotes devem ser simulados? Experimentalmente, 
pode-se observar que a partir de 3.000 (três mil) valores gerados de um GNA já se obtém-
se uma boa uniformidade na distribuição dos dados, são razoavelmente uniformes. A partir 
daí já se observa variações devido ao acaso, à aleatoriedade dos processos e dos sistemas, 
construídos ou não pelo homem.
Esta não é ainda nossa resposta porque a simulação vai além do GNA, mas já é um bom 
começo.
O Programa 10.8 gera números aleatórios e os classifica em 10 (dez) decis, ele foi 
executado para n iguais a 500, 1000, 2000, 3000, 4000, 5000 e 10000, estes resultados 
podem ser vistos na Quadro 10.3. Quanto mais números são gerados melhor a distribuição 
entre os decis.
Programa 10.8 Código Javascript para gerar e exibir números aleatórios classificados em 10 
decis.
<!doctype html>
<html>
<title>Classificação de Números Aleatórios</title>
<head>
<script>
 var q = 10, 
 n = 0, 
 sum = new Array(q);
 function Random(){
 for( var i = 0; i < q; i++ )
 sum[i] = 0;
 setInterval(Vetor,5);
 }
 function Vetor(){
 var r = Math.floor(Math.random()*q),
 wnd = document.getElementById("txt"),
 txt;
 sum[r] = sum[r]+1;
 n++;
 txt = "<table border='1'><tr>";
 for( var i = 0; i < q; i++ ){
 txt += "<td>" + (sum[i]/n).toFixed(3);
 }
 txt += "</table>";
 wnd.innerHTML = " numeros gerados = " + n + txt;
 }
window.onload = Random;
</script>
<body><div id="txt"></div></body>
Modelagem e Simulação Discreta 155
</html>
Quadro 10.3 Classes de números aleatórios utilizando o Erro: Origem da referência não 
encontrada para n iguais a 1000, 2000, 3000, 4000, 5000 e 10000, e seus respectivos 
valores mínimo, máximo e intervalo de classe
n Classes de valores gerados Xmin Xmax Xmax-Xmin
1000 0,095 0,111 0,106 0,116 0,093 0,100 0,099 0,092 0,083 0,105 0,083 0,116 0,033
2000 0,098 0,113 0,107 0,104 0,096 0,106 0,086 0,099 0,084 0,109 0,084 0,113 0,029
3000 0,098 0,112 0,104 0,104 0,092 0,109 0,087 0,096 0,088 0,110 0,087 0,112 0,025
4000 0,098 0,109 0,104 0,106 0,092 0,106 0,090 0,097 0,089 0,108 0,089 0,109 0,020
5000 0,100 0,109 0,101 0,105 0,096 0,105 0,090 0,098 0,090 0,106 0,090 0,109 0,019
10000 0,096 0,104 0,102 0,103 0,095 0,103 0,096 0,101 0,097 0,104 0,095 0,104 0,009
A Figura 10.3 apresenta a variação de ρ(1) de n valores GNA GCC do C++, para n de 500 
a 10000. O valor de ρ(1) diminui com n e, para n > 500, as sequências geradas são 
estatisticamente independentes pois ρ(1) < 0,02 – muito próximo de zero.
Figura 10.3 Variação de ρ(1) em função de n, em n é o tamanho de sequências de GNA GCC 
do C++, cada valor de ρ(1) é a média de 10 repetições da mesma sequência de tamanho n.
10.12 Questões
1. Quais as diferenças entre número aleatório e número pseudoaleatório?
2. O que é ciclo de um GNA? Qual sua importância na simulação?
3. Como avaliar a qualidade de um GNA?
4. Discuta os GNA’s propostos por L’Ecuyer. Faça uma pesquisa na Internet sobre ele.
5. Qual é o período do GCL com m = 231, a = 314159269 e b = 453806245?
10.13 Exercícios
Modelagem e Simulação Discreta 156
1. Verifique a correção das Equações 10.4 a Erro: Origem da referência não encontrada 
por meio de um programa em C.
2. Gerar 10.000 números usando a semente x0 = 1 usando o gerador xn = 75xn-1 mod (231-
1). Classificar os números em 10 classes de tamanhos iguais e teste a uniformidade 
pelo teste CQ com confiança de 95 e 99%.
3. Gerar 15 números usando a semente x0 = 1 no gerador xn = (5xn-1+1) mod 16. 
Verifique se a sequência passa no teste CQ em um nível de confiança de 95 e 99%.
4. Teste os geradores apresentados no texto em um nível de confiança de 95% e 99%.
5. Trinta números aleatórios foram gerados usando o GCL xn = 3xn-1 mod 31 com semente 
de x0 = 15. Os números foram: 14, 11, 2, 6, 18, 23, 7, 21, 1, 3, 9, 27, 19, 26, 16, 17, 20, 
29, 25, 13, 8, 24, 10, 30, 28, 22, 4, 12, 5, 15. Verifique se eles são iid.
6. Teste a fórmula recursiva da Equação 10.1 para os GCL's GCC, JAVA e MMIX, para as 
sementes 0, 1, 31, 35 e 1000.
7. Refaça o Exemplo 10.1 para xn+1 = (5xn+ 1) mod 24 e discuta seus resultados.
8. Qual é o período dos GCL:
a) xn+1 = 5xn mod 25
b) xn+1 = 7xn mod 25
9. Considere os casos descritos por Bandyopadhyay e Bhattacharya para propor e testar 
um gerador de números aleatórios para um hardware com palavra de:
a) 8 bits
b) 11 bits
c) 14 bits
Modelagem e Simulação Discreta 157
11 GERAÇÃO DE VARIÁVEIS ALEATÓRIAS
As atividades de pesquisa e desenvolvimento em engenharia fazem uso extensivo de 
simulação em computadores. Como grande parte dos sistemas físicos são afetados por 
fenômenos físicos aleatórios, é importante que essas simulações sejam capazes de 
reproduzi-los. Em geral, essas simulações utilizam variáveis aleatórias e gerá-los constitui 
uma importante etapa destas atividades.
Uma variável aleatória é uma função que mapeia os eventos definidos em um espaço 
amostral no conjunto de valores [0,1]. Diferentes variáveis aleatórias podem ser associadas a 
um experimento, o que permite expressar tanto a sua complexidade quanto a variação do 
seu comportamento através das mais diversas funções densidade de probabilidade, tornando 
possível sua simulação.
Segundo Gentle (2004), em estatística computacional, a geração de variáveis aleatórias 
normalmente é feita em duas etapas:
1. a geração de variáveis aleatórias independentes e identicamente distribuídos U com a 
distribuição uniforme no intervalo (0,1)
2. aplicar transformações a estas variáveis aleatóriasiid U(0,1) para derivar variáveis 
aleatórias de distribuições arbitrárias, Figura 11.1
Modelagem e Simulação Discreta 158
Figura 11.1 Transformação de variáveis aleatórias U(0,1) em distribuições arbitrárias pelo 
método da inversa.
Essas duas etapas são essencialmente independentes. O passo 1 é obtido por meio 
geradores de números aleatórios (GNA) e o passo 2 é resolvido pelo método da inversa.
Em princípio, a maneira mais simples de gerar variáveis aleatória X com função de 
distribuição F a partir de U(0,1) variáveis aleatórias U é aplicar a inversa F a U:
X = F-1(U) ≡ min{x | F(x) ≥ U}
Este é o método da inversa. É fácil verificar que X tem a distribuição desejada: P[ X ≤ x ] 
= P[ F-1(U) ≤ x ] = P[ U ≤ F(x) ] = F(x).
Ou seja, gerar variáveis aleatórias Xi de uma função densidade de probabilidade f(x) é 
resolver a equação Xi = F-1(ui) em que F(x) é a função densidade de probabilidade acumulada 
e ui ∼ U(0,1).
Nem sempre x = F-1(u) tem solução analítica, devendo ser considerado os seguintes 
fatores para seleção do método de geração de variáveis aleatórias:
• exatidão – deve-se usar sempre métodos exatos e utilizar métodos baseados em 
aproximação em último caso
• eficiência – dentre os diversos métodos exatos se deve sempre escolher o mais 
eficiente
• simplicidade – em geral é preferível utilizar métodos simples
11.1 Método da Inversa da FDA
O Método da Inversa da Função Distribuição Acumulada (FDA) é um dos métodos mais 
simples de geração de variáveis aleatórias de uma distribuição F contínua e estritamente 
Modelagem e Simulação Discreta 159
crescente. Nessas condições pode-se gerar uma variável aleatória utilizando o seguinte 
algoritmo:
1. Gerar u ~ U(0,1)
2. Calcular x = F-1(u), onde F-1(u) é o valor de x quando F(x) = u
Uma grande desvantagem deste é que seu uso esta limitado a distribuições que 
possuem FDA inversível como, por exemplo, as distribuições Exponencial, Logística e Pareto, 
Gumbel ou Valores Extremos e Weibull. O Quadro 11.1 lista estas distribuições de 
probabilidade, suas fdp, fda e x, a técnica de GVA destas fda, onde u ~ U(0,1).
Quadro 11.1 Distribuições de probabilidade, fdp, fda e x, a técnica de GVA destas fda, onde u 
~ U(0,1).
Distribuição f(x) F(x) x
Exponencial aexp(−a x) 1−exp (−a x) −a ln (u)
Logística
1
4 s
sech2( x−m
2 s
)
1
1+exp [−( x−m
s
)]
m−s ln ( 1
u
−1)
Pareto ( 1
x
)
a 1
a−1
(1− 1
xa−1
) [ 1
1−u (a−1)
]
1
a−1
Valores Extremos
1
s
exp[− x−m
s
−exp(− x−m
s
)] exp[−exp (− x−m
s
)] m−s ln [−ln(u)]
Weibull a
b
( x
b
)
a−1
exp[−( x
b
)
a
] 1−exp [−( x
b
)
a
] b[−ln(u)]
1
a
No Capítulo 17 estão descritos os procedimentos matemáticos para Gerar Variáveis 
Aleatórias das fdp Exponencial, Logística e Pareto, Gumbel ou Valores Extremos e Weibull, 
listadas na Erro: Origem da referência não encontrada.
Exemplo 11.1 Gerar variáveis aleatórias Xi de uma função densidade de probabilidade f(x) é 
resolver a equação Xi = F-1(ui) em que F(x) é a função densidade de probabilidade 
acumulada e ui ∼ U(0,1).
Para obter Xi = F-1(ui) pode-se resolver a equação integral ∫
−∞
x
f (x )dx=u , que nem sempre 
tem solução analítica.
Para aquelas funções em que x = F-1(u) não possuem solução analítica, foram 
idealizadas algoritmos engenhosos que, embora sejam aproximados, substituem os métodos 
numéricos de modo satisfatório, evitando esforços computacionais além do necessário, como 
nas integrações numéricas.
Modelagem e Simulação Discreta 160
11.2 Método da Convolução
Para várias distribuições estatísticas importantes, a variável aleatória desejada X pode 
ser expressa como a soma de outras variáveis aleatórias, cuja geração pode ser feita de 
maneira mais rápida do que geração direta de X. Supõe-se que X seja a soma de m variáveis 
aleatórias iid da forma X = Y1 + Y2 + … + Ym. Pode-se utilizar o seguinte algoritmo:
3. Gerar Y1, Y2 , …, Ym, cuja distribuição de probabilidade é Y
4. Retornar X = Y1 + Y2 + … + Ym.
Este método pode ser aplicado para todas as distribuições que são a soma de variáveis 
aleatórias. Como a distribuição Binomial pode ser expressa como a soma de variáveis 
aleatórias da distribuição Bernoulli, que são muito mais fáceis de serem obtidas.
Da mesma forma, a distribuição Binomial Negativa pode ser expressa como a soma de 
variáveis aleatórias da distribuição Geométrica, que também são muito mais fáceis de serem 
obtidas.
11.3 Método da Composição
A variável aleatória desejada X pode ser expressa como uma combinação linear X = c1Y1 
+ c2Y2 + … + cnYn onde Σci=1. Pode-se utilizar o seguinte algoritmo:
5. Gerar as distribiuições de probabilidade Y1, Y2 , …, Yn
6. Obter ou gerar c1, c2, …, cn tal Σci=1
7. Retornar Y = ΣciYi
11.4 Método da Aceitação Rejeição
Assumindo que uma distribuição F, contínua, possui fdp f(x), deve-se encontrar uma 
distribuição alternativa G cuja fdp g(x) englobe o mais perfeitamente possível f(x), ou seja, 
que seja majoritária sobre ela, Figura 11.2, a função G é também chamada de função 
envelope.
Modelagem e Simulação Discreta 161
Figura 11.2 Ilustração do Método da Aceitação-Rejeição
Um dos possíveis algoritmos que descrevem o Método da Aceitação Rejeição é descrito a 
seguir:
1. Gerar u ~ U(0,1)
2. Gerar uma variável Y com distribuição G independente de u
3. Se u ≤ f(Y)/[cg(Y)] então ao faça x = Y (Y é aceito), caso contrário, volte ao passo 1 (Y é 
rejeitado)
4. x é uma variável aleatória com distribuição F
A Figura 11.2 ilustra as funções envolvidas no algoritmo apresentado acima. Nela, 
pontos são gerados dentro do intervalo de g(x). Desses pontos, aqueles que caem dentro dos 
limites de f(x) são aceitos, e os que caem fora são rejeitados.
Exemplo 11.2 Obtenha o algoritmo para a geração de variáveis aleatórios Normais padrão 
pelo método da Método da Aceitação Rejeição.
A fdp de uma variável aleatória Z com distribuição z ~ N(0,1) é dada por f(z) = 2 exp(-
z2/2)/(2π)1/2. Será utilizada a função exponencial g(x) = e-x/2 para majorar f(z), com f, g: R→R. 
A Figura 11.3 ilustra o comportamento destas funções para valores positivos das abscissas.
Figura 11.3 Gráfico de f(t) = 2 exp(-t2/2)/(2π)1/2 e g(t) = e-t/2 para t ≥ 0.
Fazendo f(x)/g(x) = exp(-x2/2)/(2π)1/2/e-x/2 = exp(x/2-x2/2)/(2π)1/2.
Para resolver a equação c = max[f(x)/g(x)] basta derivar f(x)/g(x) em relação a x e igualar a 
zero (d[f(x)/g(x)]/dx=0).
Verificar que para x = 1 a razão f(x)/g(x) é máxima, logo c = f(1)/g(1) = 2/(2π)1/2
Modelagem e Simulação Discreta 162
Neste caso, f(x)/[c*g(x)] = exp(x/2-x2/2) e pode-se escrever o seguinte algoritmo:
1. gerar dois números aleatórios u1 e u2,
2. gerar uma variável aleatória G = 2*ln(u1),
3. se u2 < exp(G/2-G2/2) então faça x = G senão retorna ao procedimento 1
4. retornar x
Este algoritmo gera apenas valores positivos da fdp Normal, útil para gerar grandezas 
temporais.
Sobre o procedimento 2: como g é exponencial será utilizado o método da Inversa. 
Recomenda-se que a função envelope seja do tipo x = F−1(u), tenha inversa analítica.
De modo geral, valores de qualquer distribuição de probabilidade podem ser obtidos 
pelo Método da Aceitação Rejeição. A distribuição Beta é uma delas.
11.5 Gerar FDA
Para evitar resolver a equação integral, 
Distribuição f(x) F(x) x
Exponencial aexp(−a x) 1−exp (−a x) −a ln (u)
Logística
1
4 s
sech2( x−m
2 s
)
1
1+exp [−( x−m
s
)]
m−s ln ( 1
u
−1)
Pareto ( 1
x
)
a 1
a−1
(1− 1
xa−1
) [ 1
1−u (a−1)
]
1
a−1
Valores Extremos
1
s
exp[− x−m
s
−exp(− x−m
s
)] exp[−exp (− x−m
s
)] m−s ln [−ln(u)]
Weibull a
b
( x
b
)
a−1
exp[−( x
b
)
a
] 1−exp [−( x
b
)
a
] b[−ln(u)]
1
a
que nem sempre tem solução analítica, foram propostas aproximações (soluções 
empíricas) para algumas FDA48, como ilustrado abaixo.
FDA Exponencial
A fdp de uma variável aleatória x com distribuição exponencial é dada por:
p(x) = λe-λx, x ≥ 0, λ > 0.
O parâmetro λ é onúmero médio de ocorrências por unidade de tempo e a razão 1/λ 
expressa o tempo médio entre as ocorrências.
Ao aplicar o método da transformação inversa para a obtenção de uma variável aleatória x 
com distribuição exponencial é necessário:
1. obter a distribuição cumulativa de probabilidade F(x) = P(X ≤ x), o que resulta em F(x) 
48 Com os computadores atuais a resolução numérica da equação integral é viável pois tem baixo custo computacional.
Modelagem e Simulação Discreta 163
= ∫p(x)dx = ∫ λe-λxdx = 1-e-λx ↔ F(x) = 1-e-λx
2. gerar um número aleatório u e fazer F(x) = u ↔ P(X ≤ x)
3. resolver u = 1-e-λx para x, o que resulta em x = -λln(1-u)
4. como 1-u e u possuem distribuição uniforme no intervalo [0,1], pode-se substituir (1-u) 
por u
5. logo x = -λln(u) é uma variável aleatória x com distribuição exponencial de parâmetro 
λ
6. o valor de x foi obtido por meio de u que, por sua vez, foi obtido de um GNA
FDA Poisson
A distribuição de Poisson, estima a probabilidade de ocorrência de x sucessos em um dado 
intervalo de tempo, por meio da seguinte função densidade de probabilidade:
p(x) = p(X = x ) = e-λλx/x!, x ≥ 0, λ > 0,
em que λ é o valor esperado do número de ocorrências por unidade de tempo.
Os procedimentos computacionais para a geração de uma variável aleatória Poisson, pelo 
método da Aceitação/Rejeição, são os seguintes:
1. fazer n = 0 e p =1,
2. gerar um número aleatório un+1 e fazer p = p∗un+1,
3. se p < e-λ então aceitar X = n senão fazer n = n+1 e retornar ao procedimento 2
4. retornar X.
FDA Normal
A transformação de Box-Muller consiste na geração de pares de amostras aleatórias 
independentes com distribuição normal a partir de números aleatórios uniformemente 
distribuídos. Sejam u, v ~ U(0,1) e x, y ~ N(µ,σ2), tem-se que:
• x=μ+σ cos(2πu)√−2 ln(v )
• y=μ+σ sin(2πu)√−2 ln (v )
Trata de um método estatístico muito simples e eficaz – qualidades extremamente 
desejáveis.
FDA Normal 2
Uma outra maneira de gerar variáveis aleatórias com distribuição normal é a aproximação 
obtida a partir do Teorema do Limite Central, que consiste em gerar 12 variáveis u ~ U(0,1), 
somá-las e subtrai 6. A variável aleatória resultante tem distribuição normal 
aproximadamente padrão com valores em (-6,+6).
z=∑
i=1
12
ui−6 , z ∊ (-6,+6) e z ~ N(0,1); x=μ+σ z , x ~ N(µ,σ2).
Modelagem e Simulação Discreta 164
FDA Gamma
A soma de b variáveis aleatórias exponencialmente distribuídas tem distribuição gamma.
f (x)=ab xb−1 e−ax
(b−1)!
, x=−1
a
∑
i=1
b
ln (ui)=−
1
a
ln∏
i=1
b
u i , x ~ G(a,b).
11.6 Qualidade na Geração de Variáveis Aleatórias
É importante fazer testes nas amostras geradas para verificar a qualidade da sequência 
aleatória, como os testes de uniformidade e de aderência à distribuição de interesse. Neste 
sentido, recomenda-se os testes CQ como testes de aderência.
11.7 Algoritmos para Gerar Variáveis Aleatórias
A classe clGVA(), Programa 11.1, implementa em Javascript funções para gerar variáveis 
aleatórias das principais FDA de uso em simulação. Ela faz uso de clGNA para gerar números 
aleatórios.
Programa 11.1 Classe clGVA() em Javascript possui funções para gerar variáveis aleatórias 
das principais fda de uso em simulação
function clGVA(){
 var GNA = new clGNA();
 this.Bernoulli = function(p){
 if( GNA.gna() > p ) return 0;
 return 1; //Law(2007)
 }
 this.Beta = function(a,b){
 var x = this.Gama(a,1),
 y = this.Gama(b,1);
 return x/(x+y); //Law(2007)
 }
 this.Binomial = function(n,p){
 var x = 0;
 for( var i = 0; i < n; i++ )
 x += this.Bernoulli(p);
 return x; //Law(2007)
 }
 this.BinNegativa = function(s,p){
 var x = 0;
 for( var i = 0; i < s; i++ )
 x += this.Geometrica(p);
 return x; //Law(2007)
 }
 this.Erlang = function(b,m){
 var p = 1.0;
Modelagem e Simulação Discreta 165
 for( var i = 0; i < m; i++ )
 p *= GNA.gna();
 return -b*Math.log(p)/m; //Law(2007)
 }
 this.Exponencial = function(a){
 return -a*Math.log(GNA.gna()); //Law(2007)
 }
 this.Gama = function(a,b){
 var p = 1.0;
 for( var i = 0; i < b; i++ )
 p *= GNA.gna();
 return -Math.log(p)/a;
 }
 this.Geometrica = function(p){
 return Math.ceil( Math.log(GNA.gna())/Math.log(1-p) ); // teto = ceil Law(2007)
 }
 this.Logistica = function(m,b){
 return m-b*Math.log((1.0/GNA.gna()-1);
 }
 this.LogNormal = function(m,s){
 return Math.exp(this.Normal(m,s)); //Law(2007)
 }
 this.Normal = function(m,s){
 var u = GNA.gna(), v = GNA.gna();
 return m + s*Math.sqrt(-2.0*Math.log(u))*Math.cos(2*Math.PI*v);
 }
 this.Pareto = function(a){
 return Math.pow( 1/(1-GNA.gna()*(a-1)),1/(a-1));
 }
 this.Poisson = function(l){
 var i = -1, a = Math.exp(-l), b = 1;
 do{
 i++;
 b *= GNA.gna();
 }while( b >= a ); //Law(2007)
 return i;
 }
 this.Triangular = function(a,b,m){
 var u = GNA.gna();
 m = (m-a)/(b-a);
 if( u > m ) return 1-Math.sqrt((1-m)*(1-u));
 return Math.sqrt(m*u); //Law(2007)
 }
 this.UniformeContinua = function(a,b){
 return a+(b-a)*GNA.gna(); //Law(2007)
 }
 this.UniformeDiscreta = function(i,j){
 return Math.floor(i)+Math.floor((j-i+1)*GNA.gna()); // floor() = piso() 
Law(2007)
 }
 this.ValoresExtremos = function(a,b){
 return a-b*Math.log(-Math.log(GNA.gna()));
 }
 this.Weibull = function(a,b){
 return b*Math.pow(-Math.log(GNA.gna()),1/a); //Law(2007)
 }
}
Modelagem e Simulação Discreta 166
Exemplo 11.3 Faça um programa em C++ para gerar variáveis aleatórias da fdp Pareto 
utilizando o GNA Apple CarbonLib.
O GNA Apple CarbonLib tem m = 231-1, a = 16807 e c = 0. A função gnacl gera dados deste 
GNA com semente obtida do tempo do sistema.
A função Pareto gera variáveis aleatórias da fdp Pareto de parâmetro a e faz uso do GNA 
Apple CarbonLib gnacl.
Por fim, tomando a = 3.0 como exemplo, são geradas 10 variáveis aleatórias da fdp Pareto 
fazendo uso do GNA Apple CarbonLib.
#include <iostream>
#include <cmath>
#include <ctime>
using namespace std;
double gnacl( void ){
 static long x = time(NULL), 
 m = pow(2,31)-1;
 x = (16807*x)%m;
 return double(x)/m;
}
double Pareto( double a ){
 double u = gnacl();
 return 1.0/pow(u,1.0/a);
}
int main(void){
 double a = 3.0;
 for( int i = 0; i < 10; i++ )
 cout << Pareto(a) << endl;
 return 0;
}
Exemplo 11.4 Faça um programa em C++ para gerar variáveis aleatórias da fdp Normal 
utilizando o GNA Vax.
O GNA Vax tem m = 231, a = 69069 e c = 1. A função gnavax gera dados deste GNA com 
semente obtida do tempo do sistema.
A função Normal2 gera variáveis aleatórias da fdp Normal de parâmetros m e s e faz uso do 
GNA Vax.
Por fim, tomando m = 3.0 e s =2.0 como exemplo, são geradas 10 variáveis aleatórias da 
fdp Normal fazendo uso do GNA Vax.
#include <iostream>
#include <cmath>
#include <ctime>
using namespace std;
Modelagem e Simulação Discreta 167
#define PI 3.1415926535897932384
double gnavax( void ){
 static long x = time(NULL),
 m = pow(2,31);
 x = (69069*x+1)%m;
 return double(x)/m;
}
double Normal2( double m, double s ){ 
 double u1 = gnavax(),
 u2 = gnavax();
 return m+s*sin(2.0*PI*u1)*sqrt(-2.0*log(u2));
}
int main(void){
 double m = 3.0, s = 2.0;
 for( int i = 0; i < 10; i++ )
 cout << Normal2(m,s) << endl;
 return 0;
}
11.8 Gerar Processos de Chegada
Conhecendo-se os parâmetros da função densidade de probabilidade que governa o 
processo de chegada, deve-se gerar quantas variáveis aleatórias forem necessárias para 
processar os pacotes de chegada.
Se a função for Poisson, o intervalo médio entre chegadas é o parâmetro necessário para 
se gerar os processos de chegada.
Os parâmetros de uma função podem ser calculados por meio de estatísticas obtidas a 
partir de amostrasdo processo e, embora ele seja discreto, deve-se buscar ajustar a melhor 
função densidade de probabilidade, quer seja discreta ou contínua, dentre as disponíveis.
11.9 Questões
1. Qual é a diferença entre os símbolos u e U, conforme este texto.
2. Qual é a diferença entre número aleatório e variável aleatório.
3. Identificar as fda deste capítulo que podem ter variáveis aleatórias geradas pelos 
métodos da:
• transformação inversa
• rejeição
• composição
• convolução
Modelagem e Simulação Discreta 168
11.10 Exercícios
1. Gere variáveis aleatórias utilizando os algoritmos propostos neste capítulo e verifique 
sua aderência à distribuição com os testes CQ. Faça o teste para 50, 100 e 200 valores 
gerados com confiança de 95 e 99%.
2. Compare os resultados de variáveis aleatórias geradas pelos algoritmos propostos 
neste capítulo com os do C++11. Faça o teste para 50, 100 e 200 valores gerados com 
confiança de 95 e 99%.
3. Implemente um algoritmo para a geração de variáveis aleatórias Normais padrão f(z) 
pelo Método da Aceitação-Rejeição utilizando a função exponencial g(t) = e-t/k para majorar 
f(z) com z ≥ 0 e k = 3, 4, 5, 10.
4. Implemente, em C++11, o algoritmo desenvolvido no Exercício 3 e compare o número 
de execuções para k = 2, 3, 5 e 10.
5. Gere 100 variáveis aleatórias Exponential em C++11 e verifique sua aderência a esta 
distribuição com os testes CQ com confiança de 99%.
6. Gere 100 variáveis aleatórias Poisson em C++11 e verifique sua aderência a esta 
distribuição com os testes CQ com confiança de 99%.
Modelagem e Simulação Discreta 169
12 SELEÇÃO DE DISTRIBUIÇÕES DE PROBABILIDADE
A estrutura conceitual para a modelagem e a análise estatística de um sistema é 
esboçado na Figura 12.1. O ponto de partida de um problema é o mundo real e um conjunto 
correspondente de dados do problema, a amostra. O segundo passo consiste em encontrar 
um modelo matemático estocástico ou probabilístico para os dados. Este modelo deve conter 
o que se sabe sobre o mundo real. O modelo permite realizar cálculos e análises que levam a 
conclusões sobre a amostra. Finalmente, as conclusões sobre o modelo são convertidas para 
conclusões sobre o mundo real. Desta forma, a partir da amostra pode-se fazer afirmações 
sobre o mundo real fazendo-se uso de modelos.
Figura 12.1 Modelagem e análise matemática (Kroese & Chan, 2014).
A Estatística usa a teoria da probabilidade e outros ramos da matemática para estudar 
dados amostrais. Em particular, os dados são vistos como aplicações de variáveis aleatórias 
cuja distribuição conjunta é previamente especificada. A partir daí, a análise matemática 
atua puramente sobre o modelo e seus parâmetros (Kroese & Chan, 2014).
A noção de probabilidade é a de um experimento aleatório cujo resultado não pode ser 
previamente determinado mas que pode ser analisado. O objetivo da probabilidade é 
entender o comportamento de experimentos aleatórios através da análise matemática. Dado 
um modelo matemático para um experimento aleatório, pode-se calcular as quantidades de 
interesse, como probabilidades e valores esperados. Além disso, esses modelos matemáticos 
podem ser implementados em computador, assim torna-se possível simular experimentos 
(Kroese & Chan, 2014).
Modelagem e Simulação Discreta 170
Para identificar uma distribuição de probabilidade que represente o comportamento de 
uma variável aleatória é necessário uma amostra e métodos estatísticos que proporcionem a 
ligação entre modelos matemáticos estocásticos e o mundo real.
Teste de aderência são métodos estatísticos que permitem avaliar o ajuste de uma 
distribuição de probabilidades aos dados de uma variável aleatória, o que permite descrever 
seu comportamento.
A Figura 12.2 ilustra o processo de gerar dados representativos para simulação a partir 
de amostras de dados de um sistema computacional.
Figura 12.2 Processo de gerar dados para simulação a partir de amostras de dados de um 
sistema computacional.
A Quadro 12.1 descreve as cinco etapas necessárias para se obter uma distribuição de 
probabilidades capaz de representar o comportamento uma variável aleatória (Jain, 1991).
Quadro 12.1 Etapas para a aplicação de testes de aderência, adaptadas de Jain (1991).
1. Processo de Amostragem
• a amostragem é um conjunto de dados medidos que represente o comportamento do 
sistema
• amostras representativas permitem que resultados obtidos por meio delas sejam 
estendidos à população, isto é, podem ser generalizados
• resultados obtidos através de amostras não representativas do comportamento do 
sistema não podem ser generalizados
2. Tratamento dos Dados
• valores extremos da amostra devem ser identificados e desconsiderados
• deve-se agrupar os valores amostrados em classes
• gráficos de valores amostrados permitem avaliação visual dos mesmos, sus 
Modelagem e Simulação Discreta 171
distribuição e propriedades estatísticas
• gráfico box-plot dos valores amostrados complementam a avaliação visual dos 
mesmos
Identificação da Distribuição Estatística
uma ou mais distribuições de probabilidade que se adéquem aos dados amostrados devem 
ser identificadas
Estimação dos Parâmetros da Distribuição Identificada
os parâmetros da distribuição ou distribuições de probabilidades identificadas devem ser 
estimados a partir dos dados amostrados
Testes de Aderência
deve-se testar o ajuste dos dados amostrados à distribuição ou distribuições de 
probabilidades identificadas por meio de testes de aderência
A simulação computacional de Sistemas de Fila requer duas amostras:
1. A primeira amostra se refere ao processo de chegada de pacotes na Fila do sistema, os 
dados amostrados são intervalos de tempo entre chegadas de pacotes ou taxa de 
chegada.
2. A segunda amostra diz respeito ao processamento dos pacotes pelo Servidor do 
sistema, os dados amostrados são tempos de serviço ou taxa de serviço.
Para cada uma destas amostras deve-se ajustar uma distribuição de probabilidade e 
ambas são utilizadas para representar o comportamento do sistema, uma para gera valores 
de ic e a outra para gerar valores de ts.
Com poucos dados não se pode fazer simulação confiável. Este processo viabiliza a 
simulação ao permitir gerar incontáveis dados que, embora sejam gerados por modelos 
matemáticos, representam o comportamento do sistema e levam a conclusões válidas para 
o mundo real.
A partir de poucos dados medidos pode-se estimar uma fdp do comportamento e variáveis 
do sistema e, a partir desta fdp, pode-se gerar novos dados destas variáveis, quantos 
forem necessários.
A obtenção de dados experimentais pode ter custo elevado e esta metodologia estatística 
permite fazer mais com menos: gerar muitos dados do sistema computacional a partir de 
poucos dados medidos e representativos.
Modelagem e Simulação Discreta 172
12.1 Independência de Observações
Qualquer estado de um Processo de Markov é independente dos seus estados passados 
e, sendo assim, as amostras de um Processo de Markov devem ser independentes.
A autocorrelação é uma estatística que informa o quanto o valor de uma variável 
aleatória é capaz de influenciar seus vizinhos à distância k, k > 0. Os valores que a 
autocorrelação podem assumir variam de -1 a 1, a ausência de correlação é indicada por 0, 
ou seja, as observações da amostra são independentes.
Uma variável aleatória Xi discreta, com média da população μ = E(X) e variância σ2 = 
E[(X-μ)2], tem autocorrelação ρ(k) definida por:
ρ(k )=
E [(X i−μ)(X i+k−μ)]
σ2 =
∑
i=1
n−k
(X i−μ)(X i+k−μ)
∑
i=1
n
(Xi−μ)
2
12.1
Exemplo 12.1 Calcule ρ(1) e ρ(2) dos dados referente a ciclos de leitura de 5 unidades de 
memória: x = {37,0 54,2 55,1 28,1 24,0}.
n = 5
Cálculo da média amostral m: m = (37,0+54,2+55,1+28,1+24,0)/5 = 198,4/5 = 39,7
Cálculo da variância da amostra s2: s2 = [(37,0-39,7)2+(54,2-39,7)2+(55,1-39,7)2+(28,1-39,7)2+(24,0-39,7)2]/(5-1) = 835,7/4 = 208,9
Cálculo de ρ(1) = [(37,0-39,7)x(54,2-39,7) + (54,2-39,7)x(55,1-39,7) + (55,1-39,7)x(28,1-
39,7) + (28,1-39,7)x(24,0-39,7)]/(5-1)/208,9 = (188,0/4)/208,9 = 47,0/208,9 = 0,225.
Este valor indica que os dados estão pouco correlacionados.
Cálculo de ρ(2) = [(37,0-39,7)x(55,1-39,7) + (54,2-39,7)x(28,1-39,7) + (55,1-39,7)x(24,0-
39,7)]/3/208,9 = (-451,3/3)/208,9 = -150,4/208,9 = -0,72.
Memória de cálculo:
i xi xi-m (xi-m)x(xi+1-m) (xi-m)x(xi+2-m)
1 37,0 37,0-39,7 (37,0-39,7)x(54,2-39,7) = -2,7 (37,0-39,7)x(55,1-39,7) = -41,3
2 54,2 54,2-39,7 (54,2-39,7)x(55,1-39,7) = 14,5 (54,2-39,7)x(28,1-39,7) = -168,1
3 55,1 55,1-39,7 (55,1-39,7)x(28,1-39,7) = 15,4 (55,1-39,7)x(24,0-39,7) = -241,8
4 28,1 28,1-39,7 (28,1-39,7)x(24,0-39,7) = -11,6
5 24,0 24,0-39,7
∑ 198,4 15,7 -451,3
m39,7
s 14,5
Uma forma de avaliar visualmente a independência dos dados de uma amostra é o 
gráfico de dispersão, que é feito pelos pares ordenados (x i,xi+k) em um plano cartesiano. 
Quando eles são independentes estão dispersos aleatoriamente, caso contrário estão 
próximos de uma reta.
Exemplo 12.2 Faça o gráfico de dispersão dos pares ordenados (xi,xi+1) em um plano 
cartesiano para x = {37,0 54,2 55,1 28,1 24,0}.
Modelagem e Simulação Discreta 173
Figura 12.3 Gráficos de dispersão dos pontos (xi,xi+1) do Exemplo 12.3.
12.2 Distribuições de Probabilidade Úteis
As funções densidade de probabilidade (fdp) são inúmeras e bem diversificadas embora 
relacionadas. Leemis (2015) e Zwillinger & Kokoska (2000) apresentam figuras ilustrando a 
relação entres as diversas fdp. A Figura 12.4 ilustra o relacionamento entres funções 
densidade de probabilidade, adaptado de Zwillinger & Kokoska (2000).
Modelagem e Simulação Discreta 174
Figura 12.4 Relacionamento entres as funções densidade de probabilidade, adaptado de 
Zwillinger & Kokoska (2000).
O Quadro 12.2 apresenta as funções densidade de probabilidade mais relevantes para 
simulação.
Quadro 12.2 Funções densidade de probabilidade mais relevantes com seus parâmetros, 
média e variância (Forbes et al., 2011)
fdp FDP Parâmetros E(x) V(x)
Erlang-m
λm xm−1e−λ x
(m−1)!
, x≥0 λ > 0 m
λ
m
λ2
Exponencial a e−a x , x>0 a > 0
1
a
1
a2
Normal 1
σ√2π
e
−
(x−μ)2
2σ2
, x∈ℝ
μ ∊ (-∞,∞)
σ > 0
μ σ2
Poisson
λ x e−λ
x!
, x≥0 λ > 0 λ λ
Uniforme
1
b−a
, x∈[a ,b ] a < b
a+b
2
(b−a)2
12
Weibull b xb−1e
−( x
a
)
b
ab
, x≥0
a > 0
b > 0
aΓ(b+1
b
) a2[Γ (b+2
b
)−Γ2( b+1
b
)]
em que Γ(a)=∫
0
∞
xa−1 e−xdx .
Em Processos de Markov os eventos passados não influem nos eventos presentes, ou 
seja, para s e t > 0 então P( X > s+t | X > s ) = P( X > t ), usualmente denominados 
processos sem memória.
A distribuição Exponencial, f(x) = λe-λx, é sem memória49 (Kroese & Chan, 2014).
A função densidade acumulada (FDA) F(x) = P(X ≤ x ) = ∫
0
x
f (x)dx = 1-e-λx ∴ P(X > x ) = 
1-P(X ≤ x ) = e-λx
12.3 Estimação de Parâmetros
O método de máxima verossimilhança, assim como o método de mínimos quadrados, 
permitem a estimação dos parâmetros de modelos matemáticos. O grande obstáculo para 
sua utilização consiste na frequente incapacidade de se obter uma solução explícita para os 
problemas em questão.
49Demonstração: P(X > s+t | X > s) = P(X > s+t, X > s)/P(X > s) = P(X > s+t)/P(X > s) = e-
λ(s+t)/e-λs = e-λt = P( X > t ) c.q.d.
Modelagem e Simulação Discreta 175
12.3.1 Método da Máxima Verossimilhança
Uma amostra aleatória (X1, X2, …, Xn) retirada de uma população com uma função de 
densidade de probabilidade f(x,θ), em que θ é um vetor de parâmetros, tem uma função 
densidade de probabilidade conjunta, a função de verossimilhança L(x,θ), definida pelo 
produto das funções densidade de cada uma das observações.
L(x ,θ)=∏
i=1
n
f (x i ,θ) 12.2
O problema consiste em obter o vetor θ que maximiza L(x,θ), o que é feito igualando a 
zero as derivadas parciais da função de verossimilhança em relação ao vetor θ
∂L(x ,θ)
∂θ =
∂∏
i=1
n
f ( xi ,θ)
∂ θ =0
12.3
Na maioria dos casos é recomendável utilizar logaritmo natural da função de 
verossimilhança (lnL), pois maximizar o logaritmo natural de uma função é, em geral mais 
simples, e produz os mesmos resultados da maximização da função original.
∂ ln L(x ,θ)
∂θ =
∂ ln∏
i=1
n
f (x i ,θ)
∂θ =0
12.4
Exemplo 12.3 Seja determinar o parâmetro β da fdp Exponencial pelo método da Máxima 
Verossimilhança a partir de uma amostra aleatória (X1, X2, …, Xn).
∂L(x ,θ)
∂θ =0
f (x ,β)=1
β e
− x
β eθ={β}
L(x ,β)=∏
i=1
n
1
β e
−
X i
β
L(x ,β)=
1
βn (e
−
X 1
β +e
−
X 2
β +⋯+e
−
Xn
β )=
1
βn
e
−1
β (X1+X2+⋯+X n)
=
1
βn e
−1
β∑
i=1
n
X i
ln L(x ,β)=ln(
1
βn
e
−1
β∑
i=1
n
X i
)= ln(
1
βn )+ ln(e
−1
β∑
i=1
n
X i
)=−ln(βn)−
1
β∑
i=1
n
X i=−n ln(β)−
1
β∑
i=1
n
X i
∂ ln L(x ,β)
∂β =
∂[−n ln(β)−1
β∑
i=1
n
X i]
∂β =−n
∂ ln(β)
∂β −∑
i=1
n
X i
∂ 1
β
∂β =
1
β2∑
i=1
n
X i−
n
β=0
1
β2∑
i=1
n
X i=
n
β⇔β=
1
n
∑
i=1
n
X i
Modelagem e Simulação Discreta 176
12.3.2 Método dos Mínimos Quadrados
O método de estimação por mínimos quadrados (MMQ) permite estimar os valores dos 
parâmetros de uma função a partir de dados observados que minimiza o quadrado do 
somatório dos erros entre valores observados e estimados.
Uma amostra aleatória (fo1, fo2, …, fon) com função densidade de probabilidade fe(x,θ), 
em que θ é um vetor de m parâmetros pk, k ∈ [1,m], tem uma função de densidade de 
probabilidade dada por foi=fe(xi,θ)+εi, i ∈ [1,n].
O erro (ε) entre valores observado e estimado é dado pela Equação 12.5 e a somatória 
do quadrado dos erros (E) é expresso pela Equação 12.6.
e i=fo(x i)−f (x i ,θ) 12.5
E=∑
i=1
n
ei
2=∑
i=1
n
[ fo(x i)−f (x i ,θ)]
2 12.6
Como E possui mínimo, a solução do sistema de m equações ∂E/∂pk = 0 permite calcular 
o valor do vetor θ que minimiza E. A solução geral é dada pela Equação 12.7.
∂E
∂θ =
∂∑
i=1
n
ei
2
∂θ =
∂∑
i=1
n
[ fo (x i)−f (x i ,θ)]
2
∂θ =−∑
i=1
n
{[ fo (x i)−f (x i ,θ)]
∂ f (x i ,θ)
∂θ }=0
12.7
Conhecidos os valores observados fo(xi) nos pontos xi, i ∈ [1,n], pode-se substituir estes 
valores na Equação 12.7 e calcular θ.
12.4 Estimativa dos Parâmetros das FDP
As estimativas dos parâmetros de uma distribuição de probabilidade, por vezes, não é 
de obtenção imediata. Os parâmetros das distribuições Exponencial, Normal e Poisson, 
dentre aquelas listadas na Erro: Origem da referência não encontrada, são calculados a partir 
da média e desvio padrão da amostra. O cálculo dos parâmetros das fdp Beta, Gamma e 
Weibull são ilustrados abaixo.
12.4.1 Estimativa dos parâmetros da fdp Exponencial
Modelagem e Simulação Discreta 177
A fdp Exponencial pode ser definida como f (x)=1
a
e
− x
a ou como f (x)=be−bx , com 
parâmetros a=E[ x ] e b= 1
E [x ]
, respectivamente, Quadro 12.3.
Quadro 12.3 Definições da fdp Exponencial e seus parâmetros
fdp Parâmetro
f (x)=1
a
e
− x
a a=E[ x ]=1
n∑ x i
f (x)=be−bx b= 1
E [x ]
= n
∑ x i
12.4.2 Estimativa dos parâmetros da fdp Beta
Segundo Leite e Virgens Filho (2011), os parâmetros p e q da distribuição Beta
f (x)= 1
b−a
Γ( p+q)
Γ ( p)Γ (q)
( x−a
b−a
)
p−1
(1− x−a
b−a
)
q−1
, para X = { x1, x2, …, xn}, são estimados pelo 
algoritmo:
1. calcular V ={ v1, v2, …, vn } sendo v i=
x i−a
b−a
em que a = min{X} e b = max{X}
2. calcular m1=
1
n
∑
i=1
n
v i
3. calcular m2=
1
n
∑
i=1
n
v i
2
4. calcular p=
m1(m1−m2)
m2−m1
2
5. calcular q=
(1−m1)(m1−m2)
m2−m1
2
6. Desta forma, a distribuição Beta é adimensionalizada para o intervalo [0,1], resultando 
na nova função f (v )=
Γ( p+q)
Γ( p)Γ(q)
v p−1(1−v )q−1=
v p−1(1−v)q−1
B (p ,q)
de parâmetros p e q.
Os cálculos dos testes CQ devem utilizar o vetor V.
Exemplo 12.4 Calcular os parâmetros da fdp Beta para a amostra X: { 6,91 1,61 4,99 9,11 
9,03 9,71 0,05 5,98 5,20 9,83 }
Os dados serão ordenados como se segue.
Modelagem e Simulação Discreta 178
i 1 2 3 4 5 6 78 9 10 m1 m2
xi 0,05 1,61 4,99 5,2 5,98 6,91 9,03 9,11 9,71 9,83
vi 0,000 0,159 0,503 0,524 0,603 0,698 0,914 0,922 0,983 0,995 0,630
vi
2 0,000 0,025 0,253 0,274 0,364 0,487 0,835 0,849 0,966 0,990 0,504
a = 0,05
b = 9,83
p = 0,630*(0,630-0,504)/(0,504-0,630*0,630) = 0,736
q = (1-0,630)*0,736/0,630 = 0,433
Logo os parâmetros da fdb Beta são p = 0,736 e q = 0,433.
12.4.3 Estimativa dos parâmetros da fdp Gamma
Se X = { x1, x2, …, xn } formam um conjunto de n valores, as estimativas dos parâmetros 
da distribuição Gamma f (x)=
xa−1e
− x
b
baΓ(a)
são feitas pelas equações (Thom, 1958; Catalunha et 
al., 2012):
a=
1+√1+
4 A
3
4 A
, b=
xm
a
, A=ln(xm)−
1
n
∑
i=1
n
ln(x i) e xm=
1
n
∑
i=1
n
x i .
Exemplo 12.5 Calcular os parâmetros da fdp Gamma para a amostra X: { 6,91 1,61 4,99 
9,11 9,03 9,71 0,05 5,98 5,20 9,83 }
i 1 2 3 4 5 6 7 8 9 10 ∑ xm
xi 0,05 1,61 4,99 5,2 5,98 6,91 9,03 9,11 9,71 9,83 62,42 6,242
ln(xi) -2,996 0,476 1,607 1,649 1,788 1,933 2,201 2,209 2,273 2,285 13,425
n = 10
xm = (6,91 + 1,61 + 4,99 + 9,11 + 9,03 + 9,71 + 0,05 + 5,98 + 5,20 + 9,83)/10 = 6,24
∑ln(x) = ln(6,91) + ln(1,61) + ln(4,99) + ln(9,11) + ln(9,03) + ln(9,71) + ln(0,05) + ln(5,98) 
+ ln(5,20) + ln(9,83) = 13,43
A = ln(6,24) - 13,43/10 = 0,489
a = [1+(1+4x0,489/3)1/2]/(4x0,489) = [1+(1+0,651)1/2]/1,956 = (1+1,28)/1,956 = 1,17
b = 6,24/1,17 = 5,34
Logo os parâmetros da fdb Gamma são a =1,17 e b = 5,34.
12.4.4 Estimativa dos parâmetros da fdp Weibull
Segundo Hirata(2004), a estimativa dos parâmetros da distribuição de Weibull
f (x)=b xb−1 e
−( x
a
)
b
ab para X = { x1, x2, …, xn}, um conjunto n valores, são feitas pelas equações:
Modelagem e Simulação Discreta 179
b=( s
m
)
−1,086
e a= m
Γ(1+ 1
b
)
em que m e s são a média aritmética e o desvio padrão de X, 
respectivamente.
Exemplo 12.6 Calcular os parâmetros da fdp Weibull para a amostra X: { 6,91 1,61 4,99 
9,11 9,03 9,71 0,05 5,98 5,20 9,83 }
i 1 2 3 4 5 6 7 8 9 10 ∑ m s
xi 0,05 1,61 4,99 5,2 5,98 6,91 9,03 9,11 9,71 9,83 62,42 6,242 3,397
b = (s/m)-1,086 = (3,397/6,242)-1,086 = (0,544)-1,086 = 1,936
a = m/Γ(1+1/b) = 6,242/Γ(1+1/1,936) = 6,242/Γ(1,516) = 6,242/0,887 = 7,038
Logo os parâmetros da fdb Weibull são a = 7,038 e b = 1,936.
12.5 Identificação da Distribuição Estatística
Para fins de simulação é necessário identificar a distribuição de probabilidade Fe que 
melhor represente o comportamento do sistema. Para quantificar o grau de associação de 
uma amostra de variáveis aleatórias X = (X1, X2, …, Xn) à distribuição Fe é utilizado testes de 
aderência.
Testes de aderência fazem uso do teste de hipótese de ajuste à distribuição:
• Hipótese H0: X são observações da distribuição Fe
• Hipótese Ha: X não são observações da distribuição Fe
Etapas de um teste de hipóteses50:
1. formular o modelo estatístico para os dados
2. definir as hipóteses
3. definir uma margem de erro (α) em geral, adota-se α = 5%
4. selecionar a estatística de teste
5. calcular a estatística de teste
1. calcular a probabilidade limite (p-value)
2. decidir o teste: aceitar ou rejeitar H0 a partir do p-value
Vantagens:
50 Veja no apêndice notas sobre teste de hipóteses.
Modelagem e Simulação Discreta 180
• é uma forma automática de identificar diferenças grosseiras entre distribuições teórica 
e observada, diferenças não provocadas pela flutuação dos dados
• não depende do julgamento do avaliador
Desvantagens:
• quando se tem poucos dados, o teste é pouco sensível (deixa de perceber diferenças, 
aceitando distribuições com ajuste ruim)
• quando se tem muitos dados, as chances de se rejeitar todas as distribuições teóricas 
aumentam
• o teste de hipótese permite fixar a confiança 1-α em rejeitar uma distribuição, mas 
nada afirma quanto a confiança em aceitá-la
Dentre as principais estatísticas de teste de aderência, destacam-se o de Chi-Quadrado.
12.5.1 Teste Chi-Quadrado (CQ)
O teste CQ é usado para testar se uma distribuição de frequência observada se ajusta a 
uma distribuição específica, como a normal, exponencial ou outra qualquer. Ou seja, este 
teste permite determinar se dados observados atendem a uma determinada distribuição de 
probabilidade de p parâmetros. Sua aplicação consiste em:
• preparar um histograma com k classes para a obtenção da frequência de ocorrência 
observada Oi em cada intervalo i = 1, …, k
• determinar a frequência de ocorrências esperadas Ei para cada intervalo i obtida a 
partir da distribuição que está sendo testada
• calcular a estatística D=∑
i=1
k (Oi−Ei)
2
Ei
que tem distribuição χ2 com k-1-p graus de 
liberdade
• se D < χ2(1-α;k-1-p) não se pode rejeitar a hipótese H0 ao nível de significância α, caso 
contrário rejeita-se a hipótese H0.
A distribuição χ2 permite obter o valor de χ2(1-α,gl) com significância α e gl graus de 
liberdade.
O teste CQ:
Modelagem e Simulação Discreta 181
• funciona melhor se os intervalos do histograma são escolhidos de tal forma que os 
valores de Ei sejam iguais
• uma solução aproximada é agrupar um intervalo com Ei pequeno com algum intervalo 
vizinho
• no caso da distribuição uniforme, basta utilizar um histograma com intervalos de 
mesmo tamanho
Para o teste de aderência, a probabilidade limite do teste CQ é o termo técnico p-value e 
corresponde à probabilidade P( X > xcrítico ) = 1-p-value.
Na Figura 12.5, o valor de xcrítico divide a área sob a curva em duas regiões, a região 
hachurada em vermelho indica a probabilidade de se rejeitar a hipótese H0 ao nível de 
significância p-value, isto é, D ≥ p-value. Em cinza, é a região de probabilidade em que não 
se pode rejeitar a hipótese H0 ao nível de significância p-value, ou seja, D < p-value.
Figura 12.5 Regiões de probabilidade de aceitação (cinza) ou rejeição (vermelho) da 
hipótese H0 ao nível de significância p-value para o teste CQ.
Passo a passo do teste CQ:
1. Dada uma amostra X={x i}i=1
n
2. Classificar os dados da amostra X em k classes, Oi, i ∈ [1,k]
3. Calcula-se os parâmetros da amostra
4. Calcula-se pi, i ∈ [1,k], a partir da fdp desejada (pode requer integração numérica)
5. Calcula-se Ei, i ∈ [1,k]
6. Calcula-se D
7. Obtém-se o valor de xcrítico para o p-value a partir do Anexo e decide-se o teste
A frequência da classe i (fi), pode ser calculada pelo produto do número de observações (n = 
∑ni) pela probabilidade de ocorrência de cada classe (f i = n × pi), i ∈ [1,k]. Para calcular o 
valor de pi basta integrar a fdp desejada considerando os limites da classe.
Para calcular xc = χ2
1-α-,υ deve-se resolver a equação integral ∫
0
xc
f (x)dx=1−α em que 
Modelagem e Simulação Discreta 182
f (x )= 1
2
ν
2 Γ( ν
2
)
x
ν
2
−1
e
−x
2
é a distribuição Chi-Quadrado υ graus de liberdade e Γ é a função gama. Estes 
valores podem ser calculados numericamente ou obtidos de tabelas estatísticas (que são soluções desta 
equação integral).
Exemplo 12.7 Deseja-se verificar se o número de falhas (NF) de um sistema muda 
conforme o dia da semana. O número de falhas (NF) observadas para cada dia de uma 
semana escolhida aleatoriamente foram:
Dia da Semana NF Observadas (Oi)
segunda-feira 35
terça-feira 20
quarta-feira 30
quinta-feira 15
sexta-feira 10
sábado 10
domingo 20
Hipóteses a serem testadas:
• H0: o número de falhas não muda conforme o dia da semana
• Ha: pelo menos um dos dias da semana tem número de falhas diferente dos demais
Se pi representa a probabilidade de ocorrência de falhas no i-ésimo dia da semana:
• H0: pi = 1/7, ∀i ∊ {1, 2, …, 7}
• Ha: pi ≠ 1/7 para algum valor de i ∊ {1, 2, …, 7}
Total de falhas na semana: n = 140, Logo, se H0 for verdadeira, Ei = 140 × 1/7 = 20
Dia da Semana NF Observadas (Oi) NF Esperadas (Ei)
segunda-feira 35 20
terça-feira 20 20
quarta-feira 30 20
quinta-feira 15 20
sexta-feira 10 20
sábado 10 20
domingo 20 20
Cálculo de D = (35-20)2/20 +(20-20)2/20 + … + (20-20)2/20 = 27,5
Regra de decisão: se, para α fixado obtemos D > χ2(1-α;gl), rejeita-se a hipótese H0, caso 
contrário aceita-sea hipótese H0.
No caso da distribuição uniforme entre 0 e 1 nenhum parâmetro precisa ser estimado, p = 
0
Da tabela do Anexo: χ2(0,95;6) = 12,59.
Neste caso, χ2(0,95;6) = 12,59 e D > χ2(0,95;6), isto é, 27,5 > 12,59.
Rejeita-se H0 e conclui-se que, pelo menos, um dos dias tem número de falhas diferente 
dos demais.
Conclusão: Pelo menos um dos valores medidos do tempo entre falhas do sistema difere 
Modelagem e Simulação Discreta 183
dos demais segundo o Teste de CQ com 95% de confiança.
12.5.2 Testes CQ para fdp Beta
Os testes de CQ para aderência de amostras à função Beta devem ser feitos com os 
dados adimensionalizados para o intervalo [0,1].
12.6 Modelos para Processos de Chegada
O processo de chegadas de clientes numa fila é, em geral, estocástico. Para estudá-lo é 
necessário identificar a distribuição de probabilidade do tempo entre chegadas que, em 
geral, é exponencial.
Processos de chegada são ditos estacionários quando a distribuição de probabilidade 
que o descreve não varia com o tempo (independente do tempo), caso contrário são ditos 
processos não estacionários. Quando os tempos entre chegadas são identicamente 
distribuídos, a taxa de chegada é igual à λ com média 1/λ.
A distribuição de Poisson é usada para encontrar a probabilidade de ocorrência de 
eventos por unidade de intervalo. São condições para sua aplicação:
• deve existir apenas dois resultados mutuamente exclusivos {ocorre, não ocorre}
• os eventos devem ser independentes
• o número médio de ocorrências por unidade de intervalo deve permanecer constante
A distribuição de Poisson, Poi(λ), é apropriada para modelar eventos discretos 
independentes e com taxa de ocorrência constante.
Um exemplo clássico é a representação do número de chegadas em Sistemas de Filas. 
Este número tem uma distribuição de Poisson se a taxa média de chegada não variar ao 
longo do tempo e se os tempos entre chegadas são exponencialmente distribuídos.
Na prática, as taxas de chegada podem variar de acordo com a hora do dia ou do ano, 
mas um modelo de Poisson deve ser usado para períodos que são razoavelmente 
homogêneos. Nesta distribuição a média e a variância são iguais e podem ser estimados pela 
observação das características da amostra.
A distribuição de Poisson é de grande importância para a Teoria de Filas e para a área de 
Confiabilidade. Ela permite estudar um grande número de fenômenos observáveis como, por 
exemplo, a chegada de pacotes em filas, falhas de sistemas, requisição de pacotes em 
servidores, falhas e, de modo geral, eventos que ocorrem por unidade de área ou de tempo.
Modelagem e Simulação Discreta 184
Quando a taxa λ não varia com o tempo, a probabilidade de que haja a ocorrência de k 
eventos no intervalo (0,T] é dada por f (k ,λ)=
(λT )k e−λ T
k !
. Uma generalização importante 
desse tipo de processo é quando se considera que λ varia no tempo, λ(t). Nesse caso, tem-se 
um Processo Poisson não-estacionário e o número de chegadas m(T) é estimado pela 
integração de λ(t) para t variando de 0 a T, m(T )=∫
0
T
λ(t )dt .
12.7 Gerando Processos de Chegada
Um Processo de Poisson com parâmetro λ é aquele cujo intervalos entre chegadas tem 
distribuição exponencial do mesmo parâmetro λ. Seja ti o instante no qual a i-ésimo pacote 
chega, o instante que a próxima pacote chega, t i+1, é dada por ti+1 = ti+Xi sendo Xi ~ Exp(λ). 
Esta abordagem é utilizada nos softwares deste livro.
Uma outra abordagem para gerar N chegadas de Poisson durante um dado intervalo de 
tempo de duração T, é usar o fato que estas N chegadas são uniformemente distribuídas ao 
longo deste intervalo. Para gerar chegadas de Poisson no intervalo [0,T] faz-se:
1. gerar N números aleatórios (chegadas) de acordo com a distribuição de Poisson com 
parâmetro λT
2. gerar N números aleatórios distribuídos uniformemente correspondentes aos instantes 
t1, …, tN, no intervalo [0,T]
3. ordenar os N instantes em ordem cronológica: t1 < … < tN
12.8 Testando Homogeneidade de Amostras
Amostras de dados de um mesmo processo medidos em diferentes períodos podem 
apresentar diferenças estatísticas. Por exemplo, a quantidade de serviços que chegam em 
um sistema pode depender da hora do dia.
O método de Kruskal-Wallis é um teste não paramétrico que pode ser usado para 
determinar se três ou mais amostras independentes foram selecionadas de populações que 
possuem a mesma distribuição.
As hipóteses nula e alternativa para o teste de Kruskal-Wallis são as seguintes:
Modelagem e Simulação Discreta 185
• H0: não há diferença na função distribuição de probabilidade das amostras
• Ha: há diferença na função distribuição de probabilidade das amostras
Segundo Spiegel et al. (2013), as duas condições para se usar o teste de Kruskal-Wallis 
são que cada amostra deve ser selecionada aleatoriamente e que o tamanho de cada 
amostra deve ser no mínimo 5. Se essas condições são alcançadas, a distribuição de 
amostragem para o teste Kruskal-Wallis é aproximada por uma distribuição χ2 com graus de 
liberdade k-1, onde k é o número de amostras. Seja x ij a j-ésima observação da amostra i, a 
estatística de teste do teste de Kruskal-Wallis é calculada pela equação:
T= 12
n(n+1)∑i=1
k Ri
2
ni
−3(n+1) 12.8
em que n=∑
i=1
k
ni , Ri=∑
j=1
ni
R (xij ) , ni é o número de observações da i-ésima amostra, R(xij) 
é o rank da observação ij sendo i ∈ [1,k] e j ∈ [1,ni].
O teste de Kruskal-Wallis consiste em combinar e classificar a informação da amostra, as 
somas dos ranks de cada amostra são calculadas e usadas para calcular a estatística T, que é 
uma aproximação das variâncias das somas dos ranks. Se as amostras são selecionadas de 
populações que possuem a mesma distribuição, as somas dos ranks serão aproximadamente 
iguais e, se T < χ2(1-α;k−1) H0 não pode ser rejeitada ao nível de confiança 1-α.
Exemplo 12.8 Verifique se as amostras A, B e C, referentes aos tempos de respostas de um 
circuito integrado, possuem a mesma distribuição de probabilidade para α = 5%.
A B C
6,5 3,4 2,6
7,3 4,1 6,2
8,5 5,1 5,1
9,9 5,6 5,8
1,8 6,0 8,8
9,5 8,3 9,2
6,9 9,4 7,3
9,8 6,4
5,5
Solução: O cálculo do Rank pode ser feito por interpolação linear:
x1 1 x−xn
x1−xn
=Rank−n
x1−xn
⇒Rank=(1−n)
x−xn
x1−xn
+nx Rank
xn n
Para n = 24, x1= 1,8 e xn= 9,9 tem-se os valores de Rank:
i,j A,B,C Rank
1 1,8 1
2 2,6 3,3
3 3,4 5,5
4 4,1 7,5
5 5,1 10,4
6 5,1 10,4
Modelagem e Simulação Discreta 186
7 5,5 11,5
8 5,6 11,8
9 5,8 12,4
10 6 12,9
11 6,2 13,5
12 6,4 14,1
13 6,5 14,3
14 6,9 15,5
15 7,3 16,6
16 7,3 16,6
17 8,3 19,5
18 8,5 20
19 8,8 20,9
20 9,2 22
21 9,4 22,6
22 9,5 22,9
23 9,8 23,7
24 9,9 24
j A ARank B BRank C CRank
1 6,5 14,3 3,4 3,5 2,6 3,3
2 7,3 16,6 4,1 7,5 6,2 13,5
3 8,5 20,0 5,1 10,4 5,1 10,4
4 9,9 24,0 5,6 11,8 5,8 12,4
5 1,8 1,0 6 12,9 8,8 20,9
6 9,5 22,9 8,3 19,3 9,2 22,9
7 6,9 15,5 9,4 22,6 7,3 16,6
8 9,8 23,7 6,4 14,1
9 5,5 11,5
∑ 149,5 102,1 100,0
A B C ∑
n 9 8 7 24
R 149,5 102,1 100
R2/n 2483,36 1303,05 1428,57 5214,98
T = 12*5214,98/[24(24+1)]-3(24+1) = 29,3
χ2(1-α;k-1) = χ2(95%,2) = 5,99
Como T > χ2(95%,2), ou seja, 29,3 > 5,99, rejeita-se a hipótese de que as amostras 
possuem a mesma distribuição de probabilidade com 95% de confiança.
Conclusão: as amostras possuem a mesma distribuição de probabilidade com 95% de 
confiança segundo o teste de Kruskal-Wallis.
12.9 Questões
1. Quais as propriedades matemáticas de uma fdp?
2. Qual a importância das fdp na simulação?
3. Que cuidados devem ser tomados ao usar fdp em simulação?
4. Compare as distribuições de probabilidades apresentadas no texto.
5. Quando usar e quando não usar as distribuições de probabilidades apresentadas no 
texto.
6. Que condições devem ser seguidas ao aplicar distribuições de probabilidade?
Modelagem e Simulação Discreta 187
7. Relacione os parâmetros de fdp com os parâmetros de modelos de simulação. Faça um 
estudecaso.
8. Qual o significado matemático de E(x) e V(x). Como eles se relacionam com os 
parâmetros da fdp? Como eles são calculados?
9. Qual o significado de autocorrelação? Qual seu uso?
10.Qual o significado estatístico das hipóteses H0 e Ha?
11.Qual o significado gráfico das hipóteses H0 e Ha?
12.Qual o significado matemático das hipóteses H0 e Ha?
13.Quando se deve usar o teste CQ? Qual o procedimento para sua aplicação?
14.O que é nível de significância? Qual sua importância prática? Qual seu significado 
gráfico?
15.Relacione matematicamente o nível de significância com a hipótese H0?
16.Relacione graficamente o nível de significância com hipótese H0?
17.Dado o conjunto de valores {ai} estabeleça os passos necessários para verificar se 
estes dados se ajustam a uma fdp qualquer utilizando o teste CQ.
18.Qual o significado matemático de D no teste CQ?
19.Qual o significado estatístico de D no teste CQ?
20.Qual o significado gráfico de D no teste CQ?
21.Qual a relação entre D, teste CQ, α e gl?
22.Como se relacionam processo de chegada, filas, estatística, amostragem e simulação?
23.Porque é necessário organizar dados em classes? Qual sua importância estatística? 
Qual sua explicação matemática?
24.Discuta as aplicações do teste de Kruskal-Wallis.
25.Proponha outras maneiras de calcular o Rank do teste de Kruskal-Wallis.
12.10 Exercícios
1. Avaliar a normalidade dos dados referente aos ciclos de leitura de 15 unidades de 
memória pelos testes CQ: X = {37 54,2 55,1 28,1 24 67,9 29,7 22,9 61,8 42,9 83,5 
19,5 31,6 14 79,6}
2. Seja avaliar a normalidade dos dados referente a medição de 10 execuções de um 
benchmark utilizando o teste CQ: X = {1,9064 2,1029 1,5223 2,6183 1,4274 2,2249 
1,6974 3,1544 1,9849 1,9957}
3. Obtenha os parâmetros das fdp estudadas pelos métodos da máxima verossimilhança 
e mínimos quadrados.
4. Supondo a média de chegada de e-mail diários seja 100, qual a probabilidade de 
recebermos pelo menos 50 e-mail num dia qualquer?
Modelagem e Simulação Discreta 188
5. Se pacotes numa rede chegam com taxa λ = 4 pps, qual a probabilidade de chegar 8 
pacotes no próximo segundo?
6. A experiência indica que, em média, 20 clientes por hora param numa agência para 
acessar terminais de computador.
a. Qual é a probabilidade de 10 clientes pararem a qualquer hora?
b. Qual é a probabilidade de 10 clientes ou menos pararem em qualquer hora?
c. Qual é o valor esperado, a média, e o desvio padrão para esta distribuição?
7. Encontre a melhor fdp que se ajusta aos dados dos exercícios 1 e 2.
8. Verifique se as amostras A, B e C são homogêneas, ou seja, possuem a mesma 
distribuição de probabilidade.
A B C
70,2 76,5 66,7
92,8 101,2 88,2
18,6 20,3 17,7
96,1 104,8 91,3
53,4 58,2 50,8
2,0 2,1 1,9
15,9 17,4 15,1
35,1 38,3 33,4
96,4 105,1 91,6
40,9 44,6
97,7 106,5
49,8 54,3
62,3
41,4
4,2
9. Foram medidos valores de λ e μ de um sistema que utiliza um Xbee Pro, abaixo 
relacionados.
• λ(pps): 22 22 31 13 12 29 32 19 17 20 13 23 13 20 27 18 22 1 20 14 19 6 22 17 27 
24
• μ(pps): 33 44 13 19 28 24 35 36 34 27 14 30 23 17 23 5 20 39 37 35 23 34 22 28 
42 27
a. Elimine os dados com valores extremos das séries λ e μ.
b. Verifique se as séries λ e μ são representativas da população.
c. Verifique se as séries λ e μ são independentes.
d. Faça os gráficos de barra das séries λ e μ e interprete-os.
e. Faça os gráficos box-plot das séries λ e μ e interprete-os.
f. Calcule os valores da média e desvio padrão das séries λ e μ.
Modelagem e Simulação Discreta 189
g. Ajuste uma distribuição de probabilidade para a série λ por meio de testes de 
aderência.
h. Ajuste uma distribuição de probabilidade para a série μ por meio de testes de 
aderência.
10. Faça os testes de CQ para os dados de λ e μ da série de dados abaixo considerando as 
fdp Beta, Weibull, Gamma, Poisson e Exponencial.
• λ(pps): 24 28 20 24 28 15 24 24 23 16 28 28 32 23 22 21 19 27 28 23 36 24
• μ(pps): 19 14 18 9 29 9 25 17 30 19 12 15 9 22 22 31 19 12 12 16 30 2
11. Faça os testes de CQ para os dados das séries de dados abaixo considerando as fdp 
Beta, Weibull, Gamma e Normal.
a. λ(pps): 43 11 16 2 5 28 3 2 20 19 8 30 33 22 7 6 10 20 30 14 7 14 33 18 13 14 17 
38 28; μ(pps): 7 12 16 19 5 15 18 10 25 14 19 16 7 7 12 13 17 4 15 16 19 20 2 21 
19 16
b. λ(pps): 30 33 27 6 37 15 1 27 15 17 19 19 5 15 18 10 25 16 19 20 2 21 19; μ(pps): 
9 22 22 31 19 12 12 16 30 14 33 18 13 14 17 8 30 33 22 7 6
Modelagem e Simulação Discreta 190
13 RECURSOS DO C++ PARA A SIMULAÇÃO
A Linguagem ANSI C++11 implementou a biblioteca <random> e ampliou 
consideravelmente sua capacidade de Gerar Números Aleatórios e também de Gerar 
Variáveis Aleatórias, a saber (Brown, 2013; cppreference, 2013).
Quanto aos GNA, temos:
• Linear congruential engines: minstd_rand0, minstd_rand
• Mersenne twister engines: mt19937, mt19937_64
• Subtract with carry engines: ranlux24_base, ranlux48_base
• Discard block engines: ranlux24, ranlux48
• Shuffle order engine: knuth_b
Um exemplo de código C++11 é apresentado no Programa 13.1 utilizando o Gerador 
Mersenne Twister 64 b:
Programa 13.1 Programa em C++ 11 utilizando o Gerador Mersenne Twister 64 b
#include <random>
#include <iostream>
#include <stdio.h>
#include <time.h>
using namespace std;
double u( double a, double b ){
 static mt19937_64 eng(time(nullptr));
 static uniform_real_distribution<double> uniform_real(a,b);
 return uniform_real(eng);
}
int main( void ){
 cout << "Distribuicao Uniforme: ";
 for( int i = 0; i < 10; i++ )
 cout << u(0.0,1.0) << " ";
Modelagem e Simulação Discreta 191
 cout << endl;
 return 0;
}
Outro exemplo de código é apresentado no Programa 13.2 utilizando o Gerador 
Mersenne Twister 32 b:
Programa 13.2 Programa em C++ 11 utilizando o Gerador Mersenne Twister 32 b
#include <random>
#include <iostream>
using namespace std;
int main( void ){
 random_device rd;
 mt19937 gen(rd());
 uniform_int_distribution<> dis(1,6);
 for( int n = 0; n < 100; ++n )
 cout << dis(gen) << ' ';
 return 0;
}
Quanto a GVA, temos:
• Grupo Uniforme: uniform_int_distribution, uniform_real_distribution, generate_canonical
• Grupo Bernoulli: vbernoulli_distribution, binomial_distribution, 
negative_binomial_distribution, geometric_distribution
• Grupo Poisson: poisson_distribution, exponential_distribution, gamma_distribution, 
weibull_distribution, extreme_value_distribution
• Grupo Normal: normal_distribution, lognormal_distribution, chi_squared_distribution, 
cauchy_distribution, fisher_f_distribution, student_t_distribution
Exemplo 13.1 Elabore um programa C++ para gerar VA com distribuição uniforme usando 
GNA Mersenne Twister 32 b.
#include <random>
#include <iostream>
using namespace std;
int main( void ){
 random_device rd;
 mt19937 gen(rd());
 uniform_int_distribution<> dis(1, 6);
 for( int n = 0; n < 10; ++n )
 cout << dis(gen) << ' ';
 cout << '\n';
 return 0;
Modelagem e Simulação Discreta 192
}
fonte: <http://en.cppreference.com/w/cpp/numeric/random/uniform_int_distribution>
Exemplo 13.2 Elabore uma função C++ para gerar VA com distribuição exponencial, com 
parâmetro p = 0.5, usando GNA GCL minstd_rand
#include <random>
#include <iostream>
using namespace std;
double X( double p ){
 static random_device rd;
 static minstd_rand gna(rd());
 exponential_distribution<> gva(p);
 return gva(gna);
}
int main( void ){
 double p = 0.5;
 for( int n = 0; n < 10; ++n )
 cout << X(p) << endl;
 cout << endl;
 return 0;
}
Modelagem e Simulação Discreta 193
14 REDUÇÃO DA VARIÂNCIA
A qualidade da estimativa é medida através da largura do intervalo de confiança (IC). 
Este último depende da variância, do valor de t1-α,n-1 e do número de observações n. 
Considerando m∓t1−α ,n−1√Vn em que m, t, α, n e V são a média amostral,o ponto crítico 
da distribuição t-Student bicaudal, o nível de significância e a variância amostral, 
respectivamente.
Mantendo a média e a variância inalteradas, pode-se diminuir o valor de IC aumentando 
o valor de α (t1-α,n-1 diminui) e/ou aumentando o valor de n (t1-α,n-1 e n-1/2 diminui). Observa-se 
que, para n > 18, o valor combinando do nível de significância (α = 5%) e do tamanho da 
amostra tende a diminuir o seu efeito sobre o IC, Figura 14.1.
Figura 14.1 Variação de t0,95;n-1/n1/2 em função de n, combinando o efeito do nível de 
significância e do tamanho da amostra.
Seria oneroso diminuir um intervalo de confiança apenas aumentando n pois isto implica 
em mais amostras além de, com isto, sujeitar-se a outros erros experimentais no processo.
As técnicas de redução de variância são métodos estatísticos sofisticados que são muito 
delicados de manusear e aplicar. Mal aplicado, este tipo de técnica pode até mesmo produzir 
o efeito oposto (Chen, 2015).
Modelagem e Simulação Discreta 194
14.1 Números Aleatórios Comuns
Esta técnica é utilizado principalmente na comparação de dois sistemas semelhantes, o 
cenário a seguir ilustra seu princípio. Seja comparar o tempo de permanência médio (D) de 
duas filas A e B, ambas do tipo FIFO (Chen, 2015).
O método de números aleatórios comuns (MNAC) consiste em enviar o mesmo número 
de pacotes para dois sistemas, a mesma sequência de pacotes de chegada para as duas 
filas, com o mesmo tempo de serviço. Supondo que foram simulados n pacotes nestes 
sistemas, o i-ésimo pacote de A produz uma estimativa para E[D] que é denotado por D i,A, 
similarmente Di,B é a estimativa para E[D] do i-ésimo pacote de B.
Ao final destas N simulações, a média (DA) e a variância (s2
A) da amostra A, são dadas 
pelas fórmulas clássicas:
DA=
1
n
∑
i=1
n
Di , A 14.1
s A
2= 1
n−1
∑
i=1
n
(Di , A−DA)
2 14.2
Similarmente, as fórmulas para a amostra B que são DB e s2
B:
DB=
1
n∑i=1
n
Di ,B 14.3
sB
2= 1
n−1∑i=1
n
(Di , B−DB)
2 14.4
A comparação entre A e B consiste em calcular a diferença Δ=DA-DB, que é um estimador 
de E[DA]-E[DB]. Como estas estimativas são variáveis aleatórias, Δ é também uma variável 
aleatória. O método MNAC nos permite reduzir sua variância, ou seja:
Var [Δ]=Var [DA]+Var [DB]−2Cov [D A , DB ]
Cov [x , y ]=∑ (xi−mx)( y i−m y) em que mx=(∑ x i)/n e m y=(∑ y i)/n
Com o MNAC as duas simulações são correlacionadas. Esta correlação é positiva pois um 
aumento do tráfego levará a um aumento no número de pacotes, tanto para A quanto para B 
e, assim, provoca um aumento no E[DA] e E[DB]. Assim, Var [Δ] é menor no caso das 
simulações serem feitas com uma sequência comum do que no caso de simulações 
independentes. A verdadeira diferença entre E[DA] e E[DB] é então melhor avaliado devido a 
esta técnica.
14.2 Variáveis Antitéticas
Modelagem e Simulação Discreta 195
Variáveis antitéticas é o mais simples e um dos principais métodos para a redução da 
variância de uma estimativa. O princípio deste método para estimar E[X] de alguma variável 
aleatória denotado por X consiste em usar duas amostras de X negativamente 
correlacionados por construção.
Seja m1 uma estimativa de E[X1], obtida de uma sequência de observações X1 geradas a 
partir de uma sequência de variáveis aleatórias uniforme U(0,1), {ui} i = 1, …, n.
Seja m2 uma segunda estimativa de E[X2], obtida de uma sequência de observações X2 
geradas a partir de uma sequência de variáveis aleatórias uniforme complementar {v i = 1-
ui} i = 1, …, n.
Estas duas sequências, {u} e {v} estão negativamente correlacionados. Tem-se duas 
variáveis aleatória, m1 e m2, definindo m = (m1+m2)/2. É claro que m = E[X] e a variância de 
m é dada por:
Var [m]=
Var [X1 ]+Var [X 2]+2Cov [X1 , X 2]
4
=
Var (X )+Cov [X 1 , X 2]
2
Em que Var(X) = Var[X1] = Var[X2].
Como m1 e m2 são, por construção, negativamente correlacionados, a variância seria 
reduzida (Chen, 2015).
Exemplo 14.1 O algoritmo baixo foi feito para simular o método de números aleatórios 
comuns. Foram criados dois sistemas de fila SF1 e SF2, cada um deles com N = 5000 
pacotes, l = 300.0 pps e m = 400.0 pps. Foram gerados dois números aleatórios para SF1, 
u1 e u2; u1 usada para gerar intervalos de chegada e u2 para gerar tempos de serviço. Os 
valores de 1-u1 e 1-u2 para usados por SF2 para gerar intervalos de chegada e tempos de 
serviço, respectivamente.
Os sistemas SF1 e SF2 foram simulados 1000 vezes e calculadas a Utilização e as 
Variâncias de tsf e nf.
Os resultados são apresentados nos gráficos abaixo: U x r, V(tsf) x r e V(nf) x r.
Pode-se observar nestes gráficos uma grande flutuação nos resultados, entretanto o uso de 
variáveis antitéticas não resultou em redução da variância. 
Figura 14.2 Variação da utilização do sistema SF1 U1 e do sistema SF2 U2 em função das 
repetições r.
Modelagem e Simulação Discreta 196
Figura 14.3 Variação do tempo total no sistema do sistema SF1 V1(tsf) e do sistema SF2 
V2(tsf) em função das repetições r.
Figura 14.4 Variação do tamanho da fila do sistema SF1 V1(nf) e do sistema SF2 V2(nf) em 
função das repetições r.
Conclusão: o uso de variáveis antitéticas não apresentou redução da variância neste 
estudo de caso.
//--------------------------------------------------------------------------
#include <cmath>
#include <ctime>
#include <string>
#include <vector>
#include <algorithm>
#include <fstream>
#include <sstream>
//--------------------------------------------------------------------------
using namespace std;
//--------------------------------------------------------------------------
class clPacote{
 public:
 int nf;
 double ic, ts, cpf, eps, sps;
};
class clSF{
 private:
 double l, m, E[6], V[6];
 vector<clPacote> Pacote;
 double X ( double, double );
 void Nf ( void );
 public:
 void Iniciar ( double, double );
 void Empacotar ( double, double );
Modelagem e Simulação Discreta 197
 void Estatistica( void );
 string Valor ( void );
};
double gna( void ){
 return (rand()+1.0)/(RAND_MAX+2.0); // u in (0,1)
}
double clSF::X( double u, double p ){
 return -log(u)/p;
}
void clSF::Iniciar( double l, double m ){
 this->l = l;
 this->m = m;
 Pacote.clear();
 Pacote.push_back({0,0,0,0,0,0}); // p = 0, primeiro pacote
}
void clSF::Empacotar( double u1, double u2 ){
 clPacote P, Pa = Pacote[Pacote.size()-1];
 P.ic = X(u1,l);
 P.ts = X(u2,m);
 P.cpf = P.ic + Pa.cpf;
 P.eps = P.cpf > Pa.sps ? P.cpf : Pa.sps;
 P.sps = P.eps + P .ts;
 Pacote.push_back(P);
}
void clSF::Nf( void ){
 for( int p = 1; p < Pacote.size(); p++ ){
 Pacote[p].nf = 0;
 for( int a = p-1; a > 0; a-- )
 if( Pacote[p].cpf < Pacote[i].eps ) Pacote[p].nf++;
 eles break;
 }
}
void clSF::Estatistica( void ){
 int N = Pacote.size();
 double Sx[6]={0,0,0,0,0,0}, Sxx[6]={0,0,0,0,0,0};
 Nf();
 for( int p = 0; p < N; p++ ){
 double x;
 clPacote P = Pacote[p];
 x = P.ic; Sx[0] += x; Sxx[0] += x*x;
 x = P.ts; Sx[1] += x; Sxx[1] += x*x;
 x = P.eps-P.cpf; Sx[2] += x; Sxx[2] += x*x; // tf
 x = P.sps-P.eps; Sx[3] += x; Sxx[3] += x*x; // tps
 x = P.sps-P.cpf; Sx[4] += x; Sxx[4] += x*x; // tsf
 x = P.nf; Sx[5] += x; Sxx[5] += x*x;
 }
 for( int e = 0; e < 6; e++ ){
 E [e] = Sx[e]/N;
 V [e] = Sxx[e]/N-E[e]*E[e];
 }
}
string clSF::Valor( void ){
 int N = Pacote.size();
 double T = Pacote[N-1].sps, U = E[3]*N/T; // tps => 3
 stringstream str;
 str << V[4] << ";" << V[5] << ";" << U; // V(tsf), V(nf), U
Modelagem e Simulação Discreta 198
 return str.str();
}
void Salvar( string fn, string str ){
 ofstream fs;
 fs.open(fn);
 replace(str.begin(), str.end(),'.',',');
 fs << str;
 fs.close();
}
int main( void ){
 int N = 5000;
 double l = 300.0,
 m = 400.0;
 clSF SF1, SF2;
 stringstream csv;
 csv<< "r;V1(tsf);V1(nf);U1;V2(tsf);V2(nf);U2" << endl;
 srand(time(nullptr));
 for( int r = 0; r < 1000; r++ ){
 SF1.Iniciar(l,m);
 SF2.Iniciar(l,m);
 for( int i = 1; i < N; i++ ){
 double u1 = gna(),
 u2 = gna();
 SF1.Empacotar(u1,u2);
 SF2.Empacotar(1.0-u1,1.0-u2);
 }
 SF1.Estatistica();
 SF2.Estatistica();
 csv << r << ";" << SF1.Valor() << ";" << SF2.Valor() << endl;
 }
 Salvar("gna.nac-V-1000.out.csv", csv.str() );
 return 0;
}
14.3 Métodos Estatísticos para Comparar Resultados 
Simulados
A maioria dos projetos de análise de desempenho exigem comparar dois ou mais 
sistemas e encontrar o melhor entre eles. A presente discussão, no entanto, será limitada a 
uma comparação de apenas dois sistemas de cargas de trabalho muito semelhantes. Se 
houver mais do que dois sistemas ou se os volumes de trabalho são significativamente 
diferentes, a análise técnicas destes projetos experimental está além do escopo deste texto. 
O procedimento para número de observações pareadas e não pareadas são diferentes. Estes 
termos e os procedimentos correspondentes estão descritos a seguir iniciando com o teste 
para média zero.
14.3.1 Teste para Média Zero
Modelagem e Simulação Discreta 199
Um uso comum de intervalos de confiança é para verificar se um valor medido é 
significativamente diferente de zero. Ao comparar uma medição aleatória com zero, as 
instruções têm de ser feitas probabilisticamente, isto é, a um nível desejado de confiança. Se 
o valor medido passa no teste de diferença, com uma probabilidade maior ou igual ao nível 
de confiança especificado, 100(1-α)%, então o valor é significativamente diferente de zero.
O ensaio consiste na determinação de um intervalo de confiança e simplesmente 
verificar se o intervalo inclui zero, isto é, intercepta o eixo X. As quatro possibilidades são 
mostradas na Figura 14.5, onde IC é usado como uma abreviação para intervalo de 
confiança. O IC é mostrado por uma linha vertical vermelha que se estende entre os limites 
de confiança inferiores e superiores. A média da amostra é indicado por um círculo azul. Nos 
casos (a) e (b), o intervalo de confiança inclui o zero, e, por conseguinte, os valores de 
medição não são significativamente diferentes de zero. Nos casos em (c) e (d), o intervalo de 
confiança não inclui o zero, e, por conseguinte, o valor medido é significativamente diferente 
de zero.
Figura 14.5 Teste para uma média zero, nos casos (a) e (b) os IC incluem zero e nos casos (c) 
e (d) os IC não incluem zero.
Exemplo 14.2 A diferença entre os tempos de processamento de duas diferentes 
implementações do mesmo algoritmo foi medida em sete cargas de trabalho semelhantes. 
As diferenças entre elas são: {1,5 2,6 -1,8 1,3 -0,5 1,7 2,4}. Podemos dizer com confiança 
de 99% que uma aplicação é melhor do que a outra?
Tamanho da amostra: n = 7
Média: 7,20/7 = 1,03
Variância da amostra: 2,57
Desvio padrão da amostra: 2.571/2= 1,60
Intervalo de confiança: 1,03∓t×1,60/71/2 = 1.03 ∓ 0.605 t
100(1-α) = 99, α = 0,01, t99;6 = 0,995
Do Anexo, o valor de t com seis graus de liberdade é t0,995;6 = 3,707 (bicaudal).
O intervalo de confiança com 99% = (-4,9;7,0).
O intervalo de confiança inclui o zero. Portanto, não podemos dizer com confiança de 99% 
que existem diferenças entre as aplicações.
Modelagem e Simulação Discreta 200
14.3.2 Observações Pareadas
Se conduzir n experimentos em dois sistemas A e B de tal forma que exista uma 
correspondência de um para um entre a amostra de ordem i do sistema A a amostra de 
ordem i do sistema B, as observações são chamados pareadas. Por exemplo, se x i e yi 
representam o desempenho da i-ésima carga de trabalho, as observações são chamados 
emparelhadas. Se não há correspondência entre as duas amostras, as observações são 
chamadas não pareadas.
A análise de observações pareadas é simples. As duas amostras são tratadas como uma 
única amostra de n pares. Para cada par, a diferença no desempenho é calculada. Um 
intervalo de confiança pode ser construída para a diferença. Se o intervalo de confiança inclui 
o zero, os sistemas não são significativamente diferentes.
Quadro 14.1 Procedimento para comparar duas amostras pareadas (mesmo tamanho)
x y
x1 x1
x2 y2
x3 y3
… …
xn-1 yn-1
xn yn
Dadas duas amostras x e y, calcular z = x-y.
Se 0∈(mz−t1−α , n−1√V z
n
,m z+t1−α ,n−1√V z
n
) então não há diferença 
estatística entre as duas amostras, estatisticamente elas não são 
diferentes. Caso contrário são diferentes.
Em que mz=
1
n∑i=1
n
z i e V z=
1
n−1∑i=1
n
(zi−mz)
2
Exemplo 14.3 Seis cargas de trabalho semelhantes foram utilizados em dois sistemas. As 
observações são {5,36 16,57 0,62 1,41 0,64 7,26} e {19,12 3,52 3,38 2,50 3,60 1,74}. Um 
sistema é melhor do que o outro?
Número de observações: n = 6 (amostras pareadas)
Diferenças entre as amostras: {-13,7 13,1 -2,8 -1,1 -3,0 5,6}.
Média: -0,32
Variância da amostra: 81,62
Desvio padrão da amostra: 9,03
Intervalo de confiança: -0,32 ∓ t(81,62/6)1/2=-0,32 ∓ 3,69 t
O 0,95 quantil de uma variável t com cinco graus de liberdade é 2,571 (bicaudal)
IC com intervalo de confiança de 95%: -0,32 ∓ (2,571)(3,69)=(-9,80;9,16)
O intervalo de confiança inclui o zero. Portanto, os dois sistemas não são diferentes.
Modelagem e Simulação Discreta 201
14.3.3 Observações não Pareadas
Dadas duas amostras A e B de tamanhos na e nb, respectivamente. As observações são 
não pareadas no sentido em que não há correspondência entre os valores das amostras. Os 
passos para determinar o intervalo de confiança para a diferença entre as médias das duas 
amostras requer fazer a estimativa da variância e do número efetivo de graus de liberdade 
de cada amostra.
Quadro 14.2 Procedimento para comparar duas amostras não pareadas (tamanhos 
diferentes)
x y
x1 y1
x2 y2
x3 y3
… …
xn-1 …
xn …
ym-1
ym
Calcular:
1. mx=
1
n∑i=1
n
xi e m y=
1
m∑i=1
m
yi
2. V x=
1
n−1∑i=1
n
(xi−mx)
2
e V y=
1
m−1∑i=1
m
( y i−m y)
2
3. dm=mx−m y e s=√V x
n
+
V y
m
4. k=
(
V x
n
+
V y
m
)
2
(
V x
n
)
2
n−1
+
(
V y
m
)
2
m−1
Se 0∈(dm−t1−α ,k s ,dm+t1−α ,k s) então não há diferença estatística 
entre as duas amostras, estatisticamente elas não são diferentes. Caso 
contrário são diferentes.
Se o intervalo de confiança inclui o zero, a diferença não é significativa a 100(1-α)% de 
confiança. Se o intervalo de confiança não inclui o zero, então o sinal da diferença média 
indica qual o sistema é melhor.
Exemplo 14.4 O tempo de processamento requerido para executar um pacote foi medido 
em dois sistemas. O tempo no sistema A foi {5,36 16,57 0,62 1,41 0,64 7,26 1,74}. Os 
tempos no sistema B foram {19,12 3,52 3,38 2,50 3,60}. Os dois sistemas são 
significativamente diferentes?
Amostras não pareadas: na = 7, nb = 5
Para o sistema A: ma = 4,8, Va = 33,4, na = 7
Modelagem e Simulação Discreta 202
Para o sistema B: mb = 6,4, Vb = 50,6, nb = 5
A diferença entre as médias: dm = -1,6
Desvio padrão das duas amostras: s = 3,8
Número efetivo de graus de liberdade: k = 7
0,95 quantil da variável t, com 7 graus de liberdade: t0,95;7 = 2,365 (bicaudal)
Intervalo de confiança de 95% para a diferença de médias = (-10,6;7,4)
O intervalo de confiança inclui o zero. Portanto, a este nível de confiança os dois sistemas 
não são diferentes.
14.4 Questões
1. Como os métodos RI e ML tratam os transientes?
2. Qual a utilidade de combinar os métodos RI e remoção de transientes?
3. Qual a utilidade de combinar os métodos ML e remoção de transientes?
14.5 Exercícios
1. Foram realizadas 4 rodadas de simulação, cada uma com 10 pacotes. Os dados de E[nf], 
E[tps] e p0 estão listados abaixo. Calcule:
a) Intervalo de Confiança da média (μ) de E[nf], E[tps] e U para α = 10%, α = 5% e α = 1%.
b) Intervalo de Confiançada variância (σ2) de E[nf], E[tps] e p0 para α = 10%, α = 5% e α = 
1%.
E[nf]
i/j 1 2 3 4 5 6 7 8 9 10
1 4 3 2 2 3 3 3 4 3 2
2 7 5 4 5 5 4 4 7 4 4
3 12 18 7 2 8 8 6 9 10 6
4 20 3 13 5 4 12 9 7 8 9
E[tps]
i/j 1 2 3 4 5 6 7 8 9 10
1 1.83 1.83 1.83 1.71 1.83 1.98 1.86 1.83 1.71 1.74
2 2.13 2.04 2.01 2.16 2.13 1.86 2.07 2.07 1.98 2.07
Modelagem e Simulação Discreta 203
3 2.40 2.52 2.4 2.34 2.34 2.31 2.46 2.25 2.46 2.40
4 2.64 2.94 2.58 2.88 2.70 2.55 2.85 2.55 2.79 2.58
p0
i/j 1 2 3 4 5 6 7 8 9 10
1 0.373 0.346 0.385 0.374 0.362 0.347 0.397 0.340 0.408 0.475
2 0.256 0.252 0.341 0.264 0.275 0.355 0.330 0.231 0.322 0.374
3 0.181 0.108 0.200 0.171 0.216 0.230 0.197 0.195 0.149 0.278
4 0.116 0.008 0.165 0.033 0.022 0.134 0.078 0.116 0.031 0.190
2. Foi realizada uma rodada de simulação com 300 pacotes de tempo total no sistema, 
abaixo relacionados. Calcule o Intervalo de Confiança da média (μ) de s para α = 10%, 
α = 5% e α = 1%.
p tsf p tsf p tsf p tsf p tsf p tsf
1 0,404 51 4,476 101 0,018 151 0,016 201 0,017 251 1,321
2 1,955 52 0,017 102 3,169 152 3,266 202 0,408 252 0,716
3 0,271 53 0,015 103 1,342 153 0,720 203 1,203 253 0,017
4 0,829 54 1,373 104 0,362 154 0,309 204 0,018 254 0,378
5 0,499 55 1,720 105 0,961 155 0,013 205 0,036 255 6,478
6 0,208 56 2,215 106 0,225 156 1,066 206 1,989 256 0,164
7 2,173 57 0,281 107 0,548 157 0,012 207 0,205 257 0,212
8 2,431 58 0,432 108 0,017 158 0,898 208 0,101 258 0,057
9 2,904 59 0,059 109 0,301 159 0,067 209 0,012 259 1,737
10 0,033 60 0,391 110 3,862 160 0,189 210 2,285 260 0,820
11 3,395 61 0,011 111 0,090 161 0,037 211 0,913 261 6,078
12 0,026 62 0,123 112 5,624 162 1,260 212 0,259 262 0,097
13 0,127 63 0,160 113 1,156 163 0,092 213 0,554 263 0,126
14 0,059 64 2,769 114 0,044 164 0,009 214 0,090 264 0,137
15 0,098 65 2,005 115 0,082 165 0,038 215 0,045 265 0,778
16 2,198 66 1,549 116 1,832 166 1,421 216 3,903 266 0,491
17 0,024 67 0,030 117 0,018 167 0,075 217 0,037 267 0,029
18 0,010 68 0,058 118 0,018 168 0,051 218 0,014 268 0,446
19 0,130 69 0,015 119 0,729 169 0,042 219 0,891 269 0,960
20 0,300 70 0,016 120 0,049 170 0,362 220 0,114 270 0,101
21 0,145 71 0,053 121 0,132 171 0,809 221 0,332 271 0,056
22 0,792 72 0,136 122 0,456 172 0,015 222 0,245 272 2,138
23 0,019 73 2,812 123 0,112 173 0,046 223 0,236 273 3,339
24 5,175 74 4,056 124 0,112 174 5,506 224 0,094 274 1,143
25 0,038 75 0,010 125 0,390 175 3,050 225 2,759 275 0,017
26 0,256 76 0,883 126 0,014 176 3,730 226 0,475 276 6,556
27 1,411 77 1,156 127 0,602 177 0,559 227 6,327 277 0,026
28 0,023 78 0,074 128 2,128 178 0,010 228 0,010 278 0,336
29 0,155 79 4,526 129 1,431 179 2,912 229 3,210 279 1,251
30 0,195 80 0,026 130 1,960 180 0,143 230 0,081 280 1,006
31 4,262 81 0,088 131 0,764 181 0,359 231 0,061 281 3,183
32 1,030 82 0,010 132 5,004 182 6,021 232 0,052 282 0,091
33 3,494 83 0,053 133 0,093 183 0,236 233 0,582 283 0,036
34 3,851 84 0,014 134 0,430 184 0,009 234 0,016 284 0,917
35 0,285 85 4,128 135 1,163 185 0,128 235 0,013 285 0,013
36 5,334 86 0,190 136 2,220 186 0,055 236 0,537 286 0,026
37 0,110 87 0,092 137 1,041 187 1,142 237 0,018 287 0,410
38 0,023 88 0,081 138 0,011 188 0,023 238 5,487 288 0,009
39 0,747 89 0,352 139 2,125 189 2,876 239 0,018 289 0,126
40 2,567 90 0,901 140 0,014 190 0,055 240 2,864 290 0,022
41 0,100 91 3,335 141 4,777 191 2,458 241 3,516 291 0,009
42 2,170 92 3,692 142 6,056 192 0,429 242 4,778 292 0,016
43 0,186 93 0,129 143 0,081 193 0,016 243 5,460 293 0,057
44 2,922 94 0,033 144 0,418 194 5,417 244 1,292 294 0,022
45 1,588 95 0,016 145 0,146 195 0,126 245 0,507 295 0,422
46 0,049 96 0,010 146 0,526 196 0,223 246 4,404 296 2,829
Modelagem e Simulação Discreta 204
47 0,492 97 1,631 147 0,365 197 0,468 247 0,035 297 0,364
48 1,356 98 0,304 148 0,021 198 0,230 248 0,115 298 0,020
49 0,353 99 0,775 149 0,052 199 0,022 249 0,029 299 0,028
50 0,400 100 0,045 150 0,252 200 0,125 250 0,804 300 0,242
3. Utilize o software SF.MM1-ML-RI.cpp descrito no Anexo para realizar B rodadas de 
simulação, cada uma com M eventos e calcule os Intervalos de Confiança da média (μ) 
e da variância (σ2) de nf, tf, tps e tsf para α = 10%, α = 5% e α = 1% nos casos:
a) B = 10 e M = 2000
b) B = 10 e M = 4000
c) B = 10 e M = 6000
4. Compare estes resultados.
5. Modifique o software SF.MM1-ML-RI.cpp descrito no Anexo para realizar B rodadas de 
simulação, cada uma com M eventos e calcule os Intervalos de Confiança da média (μ) 
e da variância (σ2) de p0 para α = 10%, α = 5% e α = 1% nos casos:
a) B = 10 e M = 2000
b) B = 10 e M = 4000
c) B = 10 e M = 6000
6. Compare estes resultados.
7. Utilize o software SF.MM1-ML-RI.cpp descrito no Anexo para realizar rodadas de 
simulação com N eventos e calcule os Intervalos de Confiança da média (μ) e da 
variância (σ2) de iat, st, nq, p0, w e r para α = 10%, α = 5% e α = 1% nos casos:
a) N = 1000
b) N = 10000
c) N = 100000
8. Compare estes resultados.
Modelagem e Simulação Discreta 205
15 SOFTWARES PARA SIMULAÇÃO SISTEMAS DE FILA
Os Softwares para Simulação Sistemas de Fila são fornecidos gratuitamente no estado 
em que se encontra. Use-os por sua conta e risco. Não me responsáveis pelas ações de 
nenhum dos usuários destes softwares. Também não me responsabilizo por quaisquer danos 
causados pelo uso destes softwares. Finalmente, é responsabilidade do leitor seguir os 
padrões apropriados de integridade acadêmica.
15.1 Dicionário de Dados dos Softwares
Quadro 15.1 Dicionário de Dados dos softwares
Nome51 Descrição
B Tamanho de bloco dos métodos ML e RI
clPacote Classe com as variáveis de estado de pacotes da simulação
clRSF Classe com as variáveis de estado de Rede de Sistemas de Fila M/M/1
clSF Classe com as variáveis de estado de Sistemas de Fila M/M/1
cpf Tempo no qual o pacote chega na Fila [s]
eps Tempo no qual o pacote chega no Servidor [s]
DP Vetor de valores de desvio padrão
DP(x) Desvio padrão de x
E Vetor de valores de esperança matemática (média aritmética)
E(x) Média aritmética de x
Empacotar Método para calcular o estado de cada pacote e incluí-lo em Pacote
Estatistica Método para calcular as médias e desvios padrão da simulação
51 O termo pacote será adotado neste texto para indicar as unidades operacionais dos Sistemas de Fila; são sinônimos de pacote os ter-
mos tarefa, transação, trabalho, instrução, flops e operação, dentre outras denominações encontradas na literatura da área.
Modelagem e Simulação Discreta 206
ic Intervalo entre chegadas de pacotes na Fila [s-1]
Iniciar Método para configurar os Sistemas de Fila e gerar o pacote zero (0)
is Intervalo entre saídas de pacotes do Servidor [s-1] 
L Número de lotes do MML
l, λ Taxa de chegada de pacotes na Fila [s]
Legenda Método para criar a legenda do software
m Vetor de taxa de serviço de Servidores de RSF [s]
m, μ Taxa de serviço do Servidor [s]
ML Método que implementa o método da Média de Lotes (MML)
N Número inicial de simulações dos Sistemas de Fila
nf Tamanho da Fila
Nf Método para calcular o tamanho da Fila dos pacotes simulados
P Percentagem do total de pacotes utilizados no MRI
p Ordem dos pacotes, o primeiro pacote tem ordem zero (0)
p Parâmetro da distribuição de probabilidade Exponencial
P, Pa Instância de clPacote
Pacote Vetor de clPacote
Pi, Pf Pacotes inicial e final (MML e MRI)
r Vetor de rota de pacotes na RSF
R Número de repetições do MRI
RI Método que implementa o método de Repetições Independentes (MRI)
RSF Rede de Sistemas de Fila M/M/1
SF Vetor de Sistemas de Fila M/M/1
Simular Método para simular todos os pacotes
Resumo Método para criar tabela resumida com os valores simulados
T Duração da simulação [s]
Tabela Método para criar tabela com os valores simulados
tf Tempo de espera na Fila [s]
sps Tempo no qual o pacote sai do Servidor [s]
ts Tempo de serviço do Servidor para processar um pacote [s-1]
tsf Tempo total no Sistema de Fila [s]
Modelagem e Simulação Discreta 207
u Variável aleatória com distribuição de probabilidadeUniforme
U Utilização do Servidor
X Método para calcular variável aleatória
Quadro 15.2 Dicionário de Funções e Constantes da Biblioteca Padrão C/C++
Nome Descrição
srand Obtém a semente (valor inicial) do gerador de números (pseudo)aleatórios
time Obtém e retorna o tempo decorrido desde 01/01/1970 00:00:00 em segundos
nullptr Ponteiro nulo
rand Gera um número (pseudo)aleatório na faixa entre 0 e RAND_MAX
RAND_MAX Constante inteira definida no arquivo stdlib.h
15.2 SF.MM1.cpp
Programa 15.1 Software SF.MM1 para simulação de Sistema de Fila M/M/1
//---------------------------------------------------------------
#include <cmath>
#include <ctime>
#include <string>
#include <vector>
#include <algorithm>
#include <fstream>
#include <sstream>
//---------------------------------------------------------------
using namespace std;
//---------------------------------------------------------------
class clPacote{
 public:
 int nf;
 double ic, cpf, eps, sps;
};
class clSF{
 private:
 double l, m, E[3], DP[3];
 vector<clPacote> Pacote;
 double X ( double );
 void Empacotar ( void );
 void Nf ( void );
Modelagem e Simulação Discreta 208
 void Estatistica( void );
 string Tabela ( void );
 string Legenda ( void );
 public:
 clSF ( void );
 void Iniciar ( double, double );
 void Simular ( int );
 string Resumo ( void );
};
clSF::clSF( void ){
 srand(time(nullptr));
}
double clSF::X( double p ){
 double u = (rand()+1.0)/(RAND_MAX+2.0); // u in (0,1)
 return -log(u)/p;
}
void clSF::Iniciar( double l, double m ){
 this->l = l;
 this->m = m;
 Pacote.clear();
 Pacote.push_back({0,0,0,0,0});
}
void clSF::Empacotar( void ){
 int p;
 clPacote P, Pa;
 p = Pacote.size()-1;
 Pa = Pacote[p];
 P.ic = X(l);
 P.cpf = P.ic + Pa.cpf;
 P.eps = P.cpf > Pa.sps ? P.cpf : Pa.sps;
 P.sps = P.eps + X(m);
 P.nf = 0;
 Pacote.push_back(P);
}
void clSF::Simular( int N ){
 for( int p = 1; p < N; p++ ){
 Empacotar();
 }
 Nf();
 Estatistica();
}
void clSF::Nf( void ){
 for( int p = 1; p < Pacote.size(); p++ ){
 Pacote[p].nf = 0;
 for( int a = p-1; a > 0; a-- )
 if( Pacote[p].cpf < Pacote[i].eps ) Pacote[p].nf++;
 eles break;
Modelagem e Simulação Discreta 209
 }
 }
}
void clSF::Estatistica( void ){
 int N = Pacote.size();
 double Sx[3]={0,0,0}, Sxx[3]={0,0,0};
 for( int p = 0; p < N; p++ ){
 double x;
 clPacote P = Pacote[p];
 x = P.eps-P.cpf; Sx[0] += x; Sxx[0] += x*x;
 x = P.sps-P.eps; Sx[1] += x; Sxx[1] += x*x;
 x = P.nf; Sx[2] += x; Sxx[2] += x*x;
 }
 for( int e = 0; e < 3; e++ ){
 E [e] = Sx[e]/N;
 DP[e] = sqrt( Sxx[e]/N-E[e]*E[e] );
 }
}
string clSF::Tabela( void ){
 stringstream htm;
 htm << fixed;
 htm.precision(5);
 htm << "Simulação de Sistemas de Fila M/M/1 Método 1<hr>"
 << "Eventos do SF<hr>"
 << "<table border='1'>"
 << "<tr><th>p<th>ic<th>cpf<th>eps<th>sps<th>nf";
 for( int p = 0; p < Pacote.size(); p++ ){
 clPacote P = Pacote[p];
 htm << "<tr>"
 << "<td>" << p+1
 << "<td>" << P.ic
 << "<td>" << P.cpf
 << "<td>" << P.eps
 << "<td>" << P.sps
 << "<td>" << P.nf;
 }
 htm << "</table><br><br><br>";
 return htm.str();
}
string clSF::Resumo( void ){
 int N = Pacote.size();
 double T = Pacote[N-1].sps,
 U = E[1]*N/T;
 stringstream htm;
 htm << "<html>"
 << "<style>table{font-family: Helvetica, Arial; font-size: 22px; background-color: #f7e8d9}</style>"
 << "<body>"
 << "<div style='font-family: Helvetica, Arial; font-size: 25px; background-color: #d6e7f8'>";
 htm << fixed;
Modelagem e Simulação Discreta 210
 htm.precision(3);
 htm << Tabela();
 htm << "<br><br><br>"
 << "Resumo dos Indicadores do SF<hr>"
 << "<table>"
 << "<tr><td> l <td>=<td>" << l
 << "<tr><td> m <td>=<td>" << m
 << "<tr><td> N <td>=<td>" << N
 << "<tr><td> T <td>=<td>" << T
 << "<tr><td> E (tsf) <td>=<td>" << E [0]+E [1]
 << "<tr><td> E (nf) <td>=<td>" << E [2]
 << "<tr><td> DP(tsf) <td>=<td>" << DP[0]+DP[1]
 << "<tr><td> DP(nf) <td>=<td>" << DP[2]
 << "<tr><td> U <td>=<td>" << U
 << "</table><br><br><br>";
 htm << Legenda();
 htm << "</div></body></html>";
 return htm.str();
}
string clSF::Legenda( void ){
 stringstream htm;
 htm << "Legenda Metodo 1<hr>"
 << "<table border='1' cellpadding='3'>"
 << "<tr><th>Variável<th>Descrição <th>Unidade"
 << "<tr><td>B <td>tamanho do bloco do ML <td>[p] "
 << "<tr><td>cpf <td>chegada de pacote na Fila <td>[s] "
 << "<tr><td>DP(x)<td>desvio padrão de x <td> "
 << "<tr><td>eps <td>entrada de pacote no Servidor <td>[s] "
 << "<tr><td>E(x) <td>média aritmética de x <td> "
 << "<tr><td>ic <td>intervalo entre chegadas de pacotes na Fila <td>[s/p]"
 << "<tr><td>is <td>intervalo entre saídas de pacotes do Servidor <td>[s/p]"
 << "<tr><td>L <td>número de blocos do ML <td>[p] "
 << "<tr><td>l <td>taxa de chegada de pacotes na Fila <td>[p/s]"
 << "<tr><td>ML <td>método da Média de Lotes <td> "
 << "<tr><td>m <td>taxa de serviço do Servidor <td>[p/s]"
 << "<tr><td>m <td>vetor taxa de serviço <td>[p/s]"
 << "<tr><td>nf <td>número de pacotes da Fila <td>[p] "
 << "<tr><td>N <td>número de pacotes simulados <td>[p] "
 << "<tr><td>p0 <td>probabilidade de Servidor ocioso <td>[] "
 << "<tr><td>p <td>ordem dos pacotes <td>[p] "
 << "<tr><td>P <td>tamanho do bloco do RI <td>[%] "
 << "<tr><td>RI <td>método das Repetições Independente <td> "
 << "<tr><td>RSF <td>Rede de Sistema de Fila <td> "
 << "<tr><td>R <td>número de repetições do RI <td>[p] "
 << "<tr><td>r <td>rota de pacotes <td>[] "
 << "<tr><td>SF <td>Sistema de Fila <td> "
 << "<tr><td>sps <td>saída de pacote do Servidor <td>[s] "
 << "<tr><td>tf <td>tempo de espera de pacotes na Fila <td>[s] "
 << "<tr><td>tsf <td>tempo de processamento de pacotes no Sistema de Fila <td>[s] "
 << "<tr><td>ts <td>tempo de processamento de pacotes no Servidor <td>[s] "
 << "<tr><td>T <td>duração da Simulação <td>[s] "
 << "<tr><td>U <td>utilização do Servidor <td>[] "
 << "</table><br><br><br>";
 return htm.str();
}
void Salvar( string fn, string str ){
 ofstream fs;
Modelagem e Simulação Discreta 211
 fs.open(fn);
 replace(str.begin(), str.end(),'.',',');
 fs << str;
 fs.close();
}
int main( void ){
 int N = 5000;
 double l = 283.3,
 m = 305.7;
 clSF SF;
 SF.Iniciar(l,m);
 SF.Simular(N);
 Salvar("M1.SF.MM1.out.html", SF.Resumo() );
 return 0;
}
15.3 SF.MM1-ML-RI.cpp
Programa 15.2 Software SF.MM1 para simulação de Sistema de Fila M/M/1 com os Métodos 
Média de Lotes e Replicações Independentes
//---------------------------------------------------------------
#include <cmath>
#include <ctime>
#include <string>
#include <vector>
#include <iostream>
#include<algorithm>
#include <fstream>
#include <sstream>
//---------------------------------------------------------------
using namespace std;
//---------------------------------------------------------------
class clPacote{
 public:
 int nf;
 double ic, cpf, cps, sps;
};
class clSF{
 private:
 double l, m, E[3];
 vector<clPacote> Pacote;
 double X ( double );
 void Iniciar ( double, double );
Modelagem e Simulação Discreta 212
 void Empacotar ( void );
 void Simular ( int );
 void Nf ( void );
 void Estatistica( int, int );
 string Legenda ( void );
 void Salvar ( string, string );
 public:
 clSF( void );
 void ML ( double, double, int, int );
 void RI ( double, double, int, int, int );
};
clSF::clSF( void ){
 srand(time(nullptr));
}
double clSF::X( double p ){
 double u = (rand()+1.0)/(RAND_MAX+2.0); // u in (0,1)
 return -log(u)/p;
}
void clSF::Iniciar( double l, double m ){
 this->l = l;
 this->m = m;
 Pacote.clear();
 Pacote.push_back({0,0,0,0,0});
}
void clSF::Empacotar( void ){
 int p;
 clPacote P, Pa;
 p = Pacote.size()-1;
 Pa = Pacote[p];
 P.ic = X(l);
 P.cpf = P.ic + Pa.cpf;
 P.cps = P.cpf > Pa.sps ? P.cpf : Pa.sps;
 P.sps = P.cps + X(m);
 P.nf = 0;
 Pacote.push_back(P);
}
void clSF::Simular( int N ){
 for( int p = 1; p < N; p++ ){
 Empacotar();
 }
 Nf();
}
Modelagem e Simulação Discreta 213
void clSF::Nf( void ){
 for( int p = 1; p < Pacote.size(); p++ ){
 Pacote[p].nf = 0;
 for( int a = p-1; a-- )
 if( Pacote[p].cpf < Pacote[i].eps ) Pacote[p].nf++;
 else break; 
 }
}
void clSF::Estatistica( int Pi, int Pf ){
 double Sx[3] = {0,0,0};
 for( int p = Pi; p < Pf; p++ ){
 clPacote P = Pacote[p];
 Sx[0] += P.cps-P.cpf;
 Sx[1] += P.sps-P.cps;
 Sx[2] += P.nf;
 }
 for( int e = 0; e < 3; e++ )
 E[e] = Sx[e]/(Pf-Pi);
}
string clSF::Legenda( void ){
 stringstream htm;
 htm << "Legenda Metodo 1<hr>"
 << "<table border='1' cellpadding='3'>"
 << "<tr><th>Variável<th>Descrição <th>Unidade"
 << "<tr><td>B <td>tamanho do bloco do ML <td>[p] "
 << "<tr><td>cpf <td>chegada de pacote na Fila <td>[s] "
 << "<tr><td>DP(x)<td>desvio padrão de x <td> "
 << "<tr><td>eps <td>entrada de pacote no Servidor <td>[s] "
 << "<tr><td>E(x) <td>média aritmética de x <td> "
 << "<tr><td>ic <td>intervalo entre chegadas de pacotes na Fila <td>[s/p]"
 << "<tr><td>is <td>intervalo entre saídas de pacotes do Servidor <td>[s/p]"
 << "<tr><td>L <td>número de blocos do ML <td>[p] "
 << "<tr><td>l <td>taxa de chegada de pacotes na Fila <td>[p/s]"
 << "<tr><td>ML <td>método da Média de Lotes <td> "
 << "<tr><td>m <td>taxa de serviço do Servidor <td>[p/s]"
 << "<tr><td>m <td>vetor taxa de serviço <td>[p/s]"
 << "<tr><td>nf <td>número de pacotes da Fila <td>[p] "
 << "<tr><td>N <td>número de pacotes simulados <td>[p] "
 << "<tr><td>p0 <td>probabilidade de Servidor ocioso <td>[] "
 << "<tr><td>p <td>ordem dos pacotes <td>[p] "
 << "<tr><td>P <td>tamanho do bloco do RI <td>[%] "
 << "<tr><td>RI <td>método das Repetições Independente <td> "
 << "<tr><td>RSF <td>Rede de Sistema de Fila <td> "
 << "<tr><td>R <td>número de repetições do RI <td>[p] "
 << "<tr><td>r <td>rota de pacotes <td>[] "
 << "<tr><td>SF <td>Sistema de Fila <td> "
 << "<tr><td>sps <td>saída de pacote do Servidor <td>[s] "
 << "<tr><td>tf <td>tempo de espera de pacotes na Fila <td>[s] "
 << "<tr><td>tsf <td>tempo de processamento de pacotes no Sistema de Fila <td>[s] "
 << "<tr><td>ts <td>tempo de processamento de pacotes no Servidor <td>[s] "
 << "<tr><td>T <td>duração da Simulação <td>[s] "
 << "<tr><td>U <td>utilização do Servidor <td>[] "
 << "</table><br><br><br>";
 return htm.str();
}
void clSF::Salvar( string fn, string str ){
 ofstream fs;
Modelagem e Simulação Discreta 214
 fs.open(fn);
 replace(str.begin(), str.end(),'.',',');
 fs << str;
 fs.close();
}
void clSF::ML( double l, double m, int B, int K ){
 int N = B*K;
 stringstream htm;
 htm << fixed;
 htm.precision(2);
 htm << "<html>"
 << "<style>body {font-family: Helvetica, Arial; font-size: 22px; background-color: #d6e7f8}"
 << " table{font-family: Helvetica, Arial; font-size: 22px; background-color: #a1b2c3}</style>"
 << "<body><br><br><br>"
 << "<br> Simulacao de Sistema de Fila M/M/1 Modelo 1"
 << "<br> Media de Lotes<hr>"
 << "<br> l = " << l
 << "<br> m = " << m
 << "<br> N = " << N
 << "<br> B = " << B
 << "<br> K = " << K
 << "<br><br>"
 << "<table border='1' cellpadding='4'>"
 << "<tr><th>B<th>Pi<th>Pf<th>T<th>E[tsf]<th>E[nf]<th>U";
 Iniciar(l,m);
 Simular(N);
 htm.precision(5);
 for( int b = 0; b < B; b++ ){
 int Pi = b*K, Pf = (b+1)*K;
 Estatistica(Pi,Pf);
 double T = Pacote[Pf-1].sps-Pacote[Pi].cps,
 U = E[1]*(Pf-Pi)/T;
 cout << "SF ML - Lote " << b+1 << " Pi = " << Pi << " Pf = " << Pf-1 << 
endl;
 htm << "<tr>"
 << "<td>" << b+1
 << "<td>" << Pi
 << "<td>" << Pf-1
 << "<td>" << T
 << "<td>" << E[0]+E[1]
 << "<td>" << E[2]
 << "<td>" << U;
 }
 htm << "</table><br><br><br>";
 htm << Legenda();
 htm << "</body></html>";
 Salvar("M1.SF.MM1.ML.out.html", htm.str() );
}
void clSF::RI( double l, double m, int N, int R, int P ){
 int Pi = (1-P/100.0)*N, Pf = N;
Modelagem e Simulação Discreta 215
 stringstream htm;
 htm << fixed;
 htm.precision(2);
 htm << "<html>"
 << "<style>body {font-family: Helvetica, Arial; font-size: 22px; background-color: #d6e7f8}"
 << " table{font-family: Helvetica, Arial; font-size: 22px; background-color: #a1b2c3}</style>"
 << "<body><br><br><br>"
 << "<br> Simulação de Sistema de Fila M/M/1 Metodo 1"
 << "<br> Repetições Independentes<hr>"
 << "<br> l = " << l
 << "<br> m = " << m
 << "<br> N = " << N
 << "<br> R = " << R
 << "<br> Pi = " << Pi
 << "<br> Pf = " << Pf
 << "<br><br>"
 << "<table border='1' cellpadding='4'>"
 << "<tr><th>R<th>Pi<th>Pf<th>T<th>E[tsf]<th>E[nf]<th>U";
 htm.precision(3);
 for( int r = 0; r < R; r++ ){
 cout << "SF RI - Repeticao " << r+1 << " Pi = " << Pi << " Pf = " << Pf-1 << 
endl;
 Iniciar(l,m);
 Simular(N);
 Estatistica(Pi,Pf);
 double T = Pacote[Pf-1].sps-Pacote[Pi].cps,
 U = E[1]*(Pf-Pi)/T;
 htm << "<tr>"
 << "<td>" << r+1
 << "<td>" << Pi
 << "<td>" << Pf-1
 << "<td>" << T
 << "<td>" << E[0]+E[1]
 << "<td>" << E[2]
 << "<td>" << U;
 }
 htm << "</table><br><br><br>";
 htm << Legenda();
 htm << "</body></html>";Salvar("M1.SF.MM1.RI.out.html", htm.str() );
}
int main( void ){
 int N = 5000,
 B = 10, // ML número de lotes
 K = 500, // ML tamanho do lote
 R = 10, // RI repetições
 P = 10; // RI percentagem final
 double l = 500.0,
 m = 750.0;
 clSF SF;
Modelagem e Simulação Discreta 216
 SF.ML(l,m,B,K);
 SF.RI(l,m,N,R,P);
 return 0;
}
15.4 RSF.MM1.cpp
Programa 15.3 Software RSF.MM1 para simulação de Rede de Sistemas de Fila M/M/1
//---------------------------------------------------------------
#include <iostream>
#include <cstdlib>
#include <cmath>
#include <ctime>
#include <string>
#include <vector>
#include <algorithm>
#include <fstream>
#include <sstream>
//---------------------------------------------------------------
using namespace std;
//---------------------------------------------------------------
class clPacote{
 public:
 int nf;
 double ic, cpf, eps, sps, is;
};
class clSF{
 public:
 double l, m, E[3], DP[3];
 vector<clPacote> Pacote;
};
class clRSF{
 private:
 vector<int> r;
 vector<clSF> SF;
 double X ( double );
 void Empacotar ( int );
 void Nf ( void );
 void Estatistica( void );
 string Tabela ( int );
 string Legenda ( void );
 public:
Modelagem e Simulação Discreta 217
 clRSF ( void );
 void Iniciar ( double, vector<double>, vector<int> );
 void Simular ( int );
 string Resumo ( void );
 void Salvar ( string, string );
};
clRSF::clRSF( void ){
 srand(time(nullptr));
}
double clRSF::X( double p ){
 double u = (rand()+1.0)/(RAND_MAX+2.0); // u in (0,1)
 return -log(u)/p;
}
void clRSF::Iniciar( double l, vector<double> m, vector<int> r ){
 this->r = r;
 SF.clear();
 for( int sf = 0; sf < m.size(); sf++ ){
 clSF X;
 X.l = l;
 X.m = m[sf];
 X.Pacote.clear();
 SF.push_back(X);
 }
 for( int i = 0; i < r.size(); i++ )
 SF[r[i]].Pacote.push_back({0,0,0,0,0,0});
}
void clRSF::Empacotar( int i ){
 int p, sf;
 clPacote P, Pa;
 if( i > 0 ){
 sf = r[i-1];
 p = SF[sf].Pacote.size()-1;
 Pa = SF[sf].Pacote[p];
 P.ic = Pa.is;
 }
 else P.ic = X( SF[0].l );
 sf = r[i];
 p = SF[sf].Pacote.size()-1;
 Pa = SF[sf].Pacote[p];
 P.cpf = P.ic + Pa.cpf;
 P.eps = P.cpf > Pa.sps ? P.cpf : Pa.sps;
 P.sps = P.eps + X( SF[r[i]].m );
 P.is = P.sps - Pa.sps;
 P.nf = 0;
 SF[sf].Pacote.push_back(P);
}
void clRSF::Simular( int N ){
 for( int p = 1; p < N; p++ ){
Modelagem e Simulação Discreta 218
 for( int i = 0; i < r.size(); i++ ){
 Empacotar(i);
 }
 }
 Nf();
 Estatistica();
}
void clRSF::Nf( void ){
 for( int sf = 0; sf < SF.size(); sf++ ){
 for( int p = 1; p < SF[sf].Pacote.size(); p++ ){
 SF[sf].Pacote[p].nf = 0;
 for(int a = p-1; a > 0; a-- )
 if( SF[sf].Pacote[p].cpf < SF[sf].Pacote[i].eps )
 SF[sf].Pacote[p].nf++;
 eles break;
 }
 }
}
void clRSF::Estatistica( void ){
 for( int sf = 0; sf < SF.size(); sf++ ){
 int N = SF[sf].Pacote.size();
 double Sx [3] = {0,0,0},
 Sxx[3] = {0,0,0};
 for( int p = 0; p < N; p++ ){
 double x;
 clPacote P = SF[sf].Pacote[p];
 x = P.eps-P.cpf; Sx[0] += x; Sxx[0] += x*x;
 x = P.sps-P.eps; Sx[1] += x; Sxx[1] += x*x;
 x = P.nf; Sx[2] += x; Sxx[2] += x*x;
 }
 for( int e = 0; e < 3; e++ ){
 double md = Sx[e]/N;
 SF[sf].E [e] = md;
 SF[sf].DP[e] = sqrt( Sxx[e]/N - md*md );
 }
 }
}
string clRSF::Tabela( int sf ){
 stringstream htm;
 htm << fixed;
 htm.precision(5);
 htm << "<br> Tabela de Eventos do SF: " << sf
 << "<br><table border='1' cellpadding='1'>"
 << 
"<tr><th>SF<th>p<th>ic<th>cpf<th>eps<th>sps<th>nf<th>is";
 for( int p = 0; p < SF[sf].Pacote.size(); p++ ){
 clPacote P = SF[sf].Pacote[p];
 htm << "<tr>"
Modelagem e Simulação Discreta 219
 << "<td>" << sf
 << "<td>" << p
 << "<td>" << P.ic
 << "<td>" << P.cpf
 << "<td>" << P.eps
 << "<td>" << P.sps
 << "<td>" << P.nf
 << "<td>" << P.is;
 }
 htm << "</table>";
 return htm.str();
}
string clRSF::Resumo( void ){
 stringstream htm;
 htm << fixed;
 htm.precision(1);
 htm << "<html>"
 << "<style>body {font-family: Helvetica, Arial; font-size: 22px; background-color: #d6e7f8}"
 << " table{font-family: Helvetica, Arial; font-size: 22px; background-color: #a1b2c3}</style>"
 << "<body><br><br><br>"
 << "Simulacao de Rede de Sistemas de Fila M/M/1 Método 1"
 << "<br>RSF Tabela Metodo 1"
 << "<br>Numero de SF:" << SF.size()
 << "<br>Sequencia:";
 for( int i = 1; i < r.size(); i++ )
 htm << r[i-1] << "-" << r[i] << ";";
 htm << "</table>"
 << "<br><br><br>"
 << "<table border='1' cellpadding='4'>"
 << "<tr><th>RSF<th>l<th>m<th>N";
 htm << "<tr><td>0<td>" << SF[0].l << "<td>" << SF[0].m << 
"<td>" << SF[0].Pacote.size();
 for( int sf = 1; sf < SF.size(); sf++ )
 htm << "<tr><td>" << sf << "<td>-<td>" << SF[sf].m << "<td>" << SF[sf].Pacote.size();
 htm << "</table>";
 htm << "<br><br><br>";
 for( int sf = 0; sf < SF.size(); sf++ ) htm << Tabela(sf);
 htm << "<br><br><br>"
 << "Resumo dos Indicadores da RSF Método 1"
 << "<table border='1' cellpadding='4'>"
 << 
"<tr><th>SF<th>N<th>T<th>E[tsf]<th>E[nf]<th>DP[tsf]<th>DP[nf]<th>U";
 htm.precision(3);
 for( int sf = 0; sf < SF.size(); sf++ ){
 int N = SF[sf].Pacote.size();
 double T = SF[sf].Pacote[N-1].sps,
 U = SF[sf].E[1]*N/T;
 htm << "<tr>"
Modelagem e Simulação Discreta 220
 << "<td>" << sf
 << "<td>" << N
 << "<td>" << T
 << "<td>" << SF[sf].E [0]+SF[sf].E [1]
 << "<td>" << SF[sf].E [2]
 << "<td>" << SF[sf].DP[0]+SF[sf].DP[1]
 << "<td>" << SF[sf].DP[2]
 << "<td>" << U;
 }
 htm << "</table><br><br><br>";
 htm << Legenda();
 htm << "</body></html>";
 return htm.str();
}
string clRSF::Legenda( void ){
 stringstream htm;
 htm << "Legenda Metodo 1<hr>"
 << "<table border='1' cellpadding='3'>"
 << "<tr><th>Variável<th>Descrição <th>Unidade"
 << "<tr><td>B <td>tamanho do bloco do ML <td>[p] "
 << "<tr><td>cpf <td>chegada de pacote na Fila <td>[s] "
 << "<tr><td>DP(x)<td>desvio padrão de x <td> "
 << "<tr><td>eps <td>entrada de pacote no Servidor <td>[s] "
 << "<tr><td>E(x) <td>média aritmética de x <td> "
 << "<tr><td>ic <td>intervalo entre chegadas de pacotes na Fila <td>[s/p]"
 << "<tr><td>is <td>intervalo entre saídas de pacotes do Servidor <td>[s/p]"
 << "<tr><td>L <td>número de blocos do ML <td>[p] "
 << "<tr><td>l <td>taxa de chegada de pacotes na Fila <td>[p/s]"
 << "<tr><td>ML <td>método da Média de Lotes <td> "
 << "<tr><td>m <td>taxa de serviço do Servidor <td>[p/s]"
 << "<tr><td>m <td>vetor taxa de serviço <td>[p/s]"
 << "<tr><td>nf <td>número de pacotes da Fila <td>[p] "
 << "<tr><td>N <td>número de pacotes simulados <td>[p] "
 << "<tr><td>p0 <td>probabilidade de Servidor ocioso <td>[] "
 << "<tr><td>p <td>ordem dos pacotes <td>[p] "
 << "<tr><td>P <td>tamanho do bloco do RI<td>[%] "
 << "<tr><td>RI <td>método das Repetições Independente <td> "
 << "<tr><td>RSF <td>Rede de Sistema de Fila <td> "
 << "<tr><td>R <td>número de repetições do RI <td>[p] "
 << "<tr><td>r <td>rota de pacotes <td>[] "
 << "<tr><td>SF <td>Sistema de Fila <td> "
 << "<tr><td>sps <td>saída de pacote do Servidor <td>[s] "
 << "<tr><td>tf <td>tempo de espera de pacotes na Fila <td>[s] "
 << "<tr><td>tsf <td>tempo de processamento de pacotes no Sistema de Fila <td>[s] "
 << "<tr><td>ts <td>tempo de processamento de pacotes no Servidor <td>[s] "
 << "<tr><td>T <td>duração da Simulação <td>[s] "
 << "<tr><td>U <td>utilização do Servidor <td>[] "
 << "</table><br><br><br>";
 return htm.str();
}
void clRSF::Salvar( string fn, string str ){
 ofstream fs;
 fs.open(fn);
 replace(str.begin(), str.end(),'.',',');
 fs << str;
 fs.close();
}
int main( void ){
Modelagem e Simulação Discreta 221
 int N = 50;
 vector<int> r = { 0, 1, 2, 1, 3, 1, 4, 1, 2, 1, 0 };
 double l = 1200;
 vector<double> m = { 1000, 1000, 1000, 1000, 1000 };
 clRSF RSF;
 RSF.Iniciar(l,m,r);
 RSF.Simular(N);
 RSF.Salvar( "M1.RSF.MM1.out.html", RSF.Resumo() );
 return 0;
}
15.5 RSF.MM1-ML-RI.cpp
Programa 15.4 Software RSF.MM1 para simulação de Rede de Sistemas de Fila Software 
SF.MM1 com os Métodos Média de Lotes e Replicações Independentes
//---------------------------------------------------------------
#include <iostream>
#include <cstdlib>
#include <cmath>
#include <ctime>
#include <string>
#include <vector>
#include <algorithm>
#include <fstream>
#include <sstream>
//---------------------------------------------------------------
using namespace std;
//---------------------------------------------------------------
class clPacote{
 public:
 int nf;
 double ic, cpf, cps, sps, is;
};
class clSF{
 public:
 double l, m, E[3];
 vector<clPacote> Pacote;
};
class clRSF{
 private:
 vector<int> r;
Modelagem e Simulação Discreta 222
 double X ( double );
 void Empacotar( int );
 void Nf ( void );
 public:
 vector<clSF> SF;
 clRSF();
 void Iniciar ( double, vector<double>, vector<int> );
 void Simular ( int );
 void Estatistica( int, int, int );
 string Legenda ( void );
};
clRSF::clRSF(){
 srand(time(nullptr));
}
double clRSF::X( double p ){
 double u = (rand()+1.0)/(RAND_MAX+2.0); // u in (0,1)
 return -log(u)/p;
}
void clRSF::Iniciar( double l, vector<double> m, vector<int> r ){
 this->r = r;
 SF.clear();
 for( int sf = 0; sf < m.size(); sf++ ){
 clSF X;
 X.l = l;
 X.m = m[sf];
 X.Pacote.clear();
 SF.push_back(X);
 }
 for( int i = 0; i < r.size(); i++ )
 SF[r[i]].Pacote.push_back({0,0,0,0,0,0});
}
void clRSF::Empacotar( int i ){
 int p, sf;
 clPacote P, Pa;
 if( i > 0 ){
 sf = r[i-1];
 p = SF[sf].Pacote.size()-1;
 Pa = SF[sf].Pacote[p];
 P.ic = Pa.is;
 }
 else P.ic = X(SF[0].l);
 sf = r[i];
 p = SF[sf].Pacote.size()-1;
 Pa = SF[sf].Pacote[p];
 P.cpf = P.ic + Pa.cpf;
Modelagem e Simulação Discreta 223
 P.cps = P.cpf > Pa.sps ? P.cpf : Pa.sps;
 P.sps = P.cps + X(SF[sf].m);
 P.is = P.sps - Pa.sps;
 P.nf = 0;
 SF[sf].Pacote.push_back(P);
}
void clRSF::Simular( int N ){
 for( int p = 1; p < N; p++ )
 for( int i = 0; i < r.size(); i++ )
 Empacotar(i);
 Nf();
}
void clRSF::Nf( void ){
 for( int sf = 0; sf < SF.size(); sf++ ){
 for( int p = 1; p < SF[sf].Pacote.size(); p++ ){
 SF[sf].Pacote[p].nf = 0;
 for( int a = p-1; a > 0; a-- )
 if(SF[sf].Pacote[p].cpf < SF[sf].Pacote[i].eps)
 SF[sf].Pacote[p].nf++;
 eles break;
 }
 }
}
void clRSF::Estatistica( int sf, int Pi, int Pf ){
 double Sx[3] = {0,0,0};
 for( int p = Pi; p < Pf; p++ ){
 clPacote P = SF[sf].Pacote[p];
 Sx[0] += P.sps-P.cps; // 0-ts
 Sx[1] += P.sps-P.cpf; // 1-tsf
 Sx[2] += P.nf; // 2-nf
 }
 for( int e = 0; e < 3; e++ ){
 SF[sf].E[e] = Sx[e]/(Pf-Pi);
 }
}
string clRSF::Legenda( void ){
 stringstream htm;
 htm << "Legenda<hr>"
 << "<table>"
 << "<tr><td> l <td>=<td> taxa de chegada de pacotes na Fila"
 << "<tr><td> m <td>=<td> taxa de serviço do Servidor"
 << "<tr><td> N <td>=<td> numero de pacotes simulados"
 << "<tr><td> T <td>=<td> duração da simulação"
 << "<tr><td> p <td>=<td> ordem dos pacotes"
 << "<tr><td> ic <td>=<td> intervalo entre chegadas de pacotes na Fila"
 << "<tr><td> cpf <td>=<td> tempo de chegada de pacote na Fila"
 << "<tr><td> cps <td>=<td> tempo de chegada de pacote no Servidor"
 << "<tr><td> sps <td>=<td> tempo de saída de pacote do Servidor"
 << "<tr><td> tf <td>=<td> tempo de espera na Fila"
 << "<tr><td> ts <td>=<td> tempo de permanecia no Servidor"
 << "<tr><td> tsf <td>=<td> tempo total no Sistema de Fila"
Modelagem e Simulação Discreta 224
 << "<tr><td> nf <td>=<td> comprimento da Fila"
 << "<tr><td> is <td>=<td> intervalo entre saídas de pacotes do Servidor"
 << "<tr><td> E(x)<td>=<td> media aritmética de x"
 << "<tr><td> U <td>=<td> utilização do Servidor"
 << "</table>"
 << "<br><br><br>";
 return htm.str();
}
void Salvar( string fn, string str ){
 ofstream fs;
 fs.open(fn);
 replace(str.begin(), str.end(),'.',',');
 fs << str;
 fs.close();
}
void ML(double l, vector<double> m, vector<int> r, int N, int L){
 stringstream htm;
 htm << fixed;
 htm.precision(7);
 htm << "<html><body>"
 << "<br> Rede de Sistemas de Fila M/M/1"
 << "<br> Media de Lotes <hr>"
 << "<br> N = " << N
 << "<br> L = " << L
 << "<br>Número de SF:" << m.size()
 << "<br>Sequência:";
 for( int i = 1; i < r.size(); i++ )
 htm << r[i-1] << "-" << r[i] << ";";
 htm << "</table>"
 << "<br><br>"
 << "<table border='1' cellpadding='0'>"
 << "<tr><td>SF<td>l<td>m";
 for( int s = 0; s < m.size(); s++ ){
 htm << "<tr><td>" << s;
 if( s == 0) htm << "<td>" << l;
 else htm << "<td>-";
 htm << "<td>" << m[s];
 }
 htm << "</table>"
 << "<br><br>"
 << "<table border='1' cellpadding='0'>"
 << "<td>SF<td>L<td>Pi<td>Pf<td>T<td>E[tsf]<td>E[nf]<td>U";
 clRSF RSF;
 RSF.Iniciar(l,m,r);
 RSF.Simular(N);
 for( int sf = 0; sf < m.size(); sf++ ){
 int B = RSF.SF[sf].Pacote.size()/L;
 for( int i = 0; i < L; i++ ){
 int Pi = i*B, Pf = (i+1)*B;
Modelagem e Simulação Discreta 225
 cout << " RSF ML - Lote " << sf << " " << i << " Pi = " << Pi << " Pf = " << Pf-1 << endl;
 RSF.Estatistica(sf,Pi,Pf);
 double T = RSF.SF[sf].Pacote[Pf-1].sps
 - RSF.SF[sf].Pacote[Pi].cps,
 U = RSF.SF[sf].E[0]*(Pf-Pi)/T;
 htm << "<tr>"
 << "<td>" << sf
 << "<td>" << i+1
 << "<td>" << Pi
 << "<td>" << Pf-1
 << "<td>" << T
 << "<td>" << RSF.SF[sf].E[1]
 << "<td>" << RSF.SF[sf].E[2]
 << "<td>" << U;
 }
 htm << endl;
 }
 htm << "</table><br><br><br>";
 htm << RSF.Legenda();
 htm << "</html>";
 Salvar("RSF.MM1.ML.out.html", htm.str() );
}
void RI( double l, vector<double> m, vector<int> r, int N, int R, int P ){
 clRSF RSF;
 stringstream htm;
 htm << fixed;
 htm.precision(7);
 htm << "<html><body>"
 << "<br> Rede de Sistemas de Fila M/M/1"
 << "<br> RepetiçõesIndependentes <hr>"
 << "<br> N = " << N
 << "<br> R = " << R
 << "<br> P = " << P << "%"
 << "<br>Número de SF:" << m.size()
 << "<br>Sequência:";
 for( int i = 1; i < r.size(); i++ )
 htm << r[i-1] << "-" << r[i] << ";";
 htm << "</table>"
 << "<br><br>"
 << "<table border='1' cellpadding='0'>"
 << "<tr><td>SF<td>l<td>m";
 for( int s = 0; s < m.size(); s++ ){
 htm << "<tr><td>" << s;
 if( s == 0 ) htm << "<td>" << l;
 else htm << "<td>-";
 htm << "<td>" << m[s];
 }
 htm << "</table>"
 << "<br><br>"
Modelagem e Simulação Discreta 226
 << "<table border='1' cellpadding='0'>"
 << "<td>SF<td>R<td>Pi<td>Pf<td>T<td>E[tsf]<td>E[nf]<td>U";
 for( int i = 1; i <= R; i++ ){
 RSF.Iniciar(l,m,r);
 RSF.Simular(N);
 for( int sf = 0; sf < m.size(); sf++ ){
 int Pf = RSF.SF[sf].Pacote.size(),
 Pi = (1-P/100.0)*Pf;
 cout << " RSF RI - repetição " << sf << " " << i 
 << " Pi = " << Pi << " Pf = " << Pf << endl;
 RSF.Estatistica(sf,Pi,Pf);
 double T = RSF.SF[sf].Pacote[Pf-1].sps
 - RSF.SF[sf].Pacote[Pi].cps,
 U = RSF.SF[sf].E[0]*(Pf-Pi)/T;
 htm << "<tr>"
 << "<td>" << sf
 << "<td>" << i
 << "<td>" << Pi
 << "<td>" << Pf-1
 << "<td>" << T
 << "<td>" << RSF.SF[sf].E[1]
 << "<td>" << RSF.SF[sf].E[2]
 << "<td>" << U;
 }
 htm << endl;
 }
 htm << "</table><br><br><br>";
 htm << RSF.Legenda();
 htm << "</html>";
 Salvar("RSF.MM1.RI.out.html", htm.str() );
}
int main( void ){
 int N = 5000;
 vector<int> r = { 0, 1, 2, 1, 3, 1, 4, 1, 2, 1, 0 };
 double l = 1388;
 vector<double> m = { 1812, 2250, 7500, 4000, 20000 };
 int L = 10, // ML número de lotes
 R = 10, // RI repetições
 P = 10; // RI percentagem final
 ML(l,m,r,N,L);
 RI(l,m,r,N,R,P);
 return 0;
}
Modelagem e Simulação Discreta 227
16 MODELO ANALÍTICO DE SISTEMAS DE FILA M/M/1
Uma vez que a soma de todas probabilidades deve ser igual a 1, tem-se a seguinte 
expressão para a probabilidade de zero pacote na Fila do sistema:
16.1
Demonstração:
∑
i=0
∞
pi=1⇒∑
i=0
∞
p0ρ
i=1⇒ p0∑
i=0
∞
ρi=1⇒ p0=
1
∑
i=0
∞
ρi
= 1
1+∑
i=1
∞
ρi
= 1
1+ ρ
1−ρ
=1−ρ
Nota: ∑
n=1
∞
xn= x
1−x
,|x|<1 , soma da progressão geométrica infinita (Polyanin & Manzhirov, 2007, pag. 357).
Substituindo p0 em pn, obtém-se:
pn=(1−ρ)ρ
n 16.2
Pode-se derivar a partir de pn, as propriedades das filas M/M/1 que foram apresentadas 
na Equação 3.4. Por exemplo, a Utilização do Servidor é dada pela probabilidade de se ter 
uma ou mais pacotes no sistema:
U=1−p0=ρ 16.3
O número médio de pacotes no sistema é dado por:
E[n]=∑
n=1
∞
n pn=∑
n=1
∞
n(1−ρ)ρn=
ρ
1−ρ 16.4
Demonstração (Mor, 2013, p. 145):
p0=1−ρ
∑
n=1
∞
n (1−ρ)ρn=(1−ρ)∑
n=1
∞
nρn=(1−ρ)∑
n=1
∞
ρ
dρn
d ρ
=(1−ρ)ρ
d∑
n=1
∞
ρn
dρ
=(1−ρ)ρ
d ( ρ
1−ρ
)
dρ
=
ρ
1−ρ
Modelagem e Simulação Discreta 228
Jain (1991) apresenta uma demostração baseada no Processo Nascimento Morte que é muito mais 
interessante.
A variância do número de pacotes no sistema é
V [n]=E[n2]−(E[n])2=∑
n=1
∞
n2(1−ρ)ρn−(E [n])2=
ρ
(1−ρ)2 16.5
A probabilidade de n ou mais pacotes no sistema é
P(k≥n)=∑
k=n
∞
(1−ρ)ρk=ρn
16.6
O tempo médio de resposta pode ser calculado usando a Lei de Little, que estabelece 
que
númeromédio de tarefas nosistema=taxade chegada×tempo médioderesposta 16.7
isto é
E[n]=λ E [r ]⇔E [r ]=
E[n]
λ ⇔ E[r ]=
ρ
(1−ρ)λ
⇔E[r ]= 1
(1−ρ)μ 16.8
A função de distribuição acumulada (FDA) do tempo de resposta é
F(r)=1−e−μ(1−ρ)r 16.9
Note-se que o tempo de resposta é distribuído exponencialmente. A partir da qual pode-
se calcular seus percentis. Por exemplo, o q-percentil do tempo de resposta pode ser 
calculado por
F(rq)=
q
100
⇔1−e−μ (1−ρ)r q= q
100
⇔rq=
1
μ(1−ρ)
ln( 100
100−q
) 16.10
Da mesma forma, a FDA do tempo de espera é dado por
F(w)=1−ρ e−μ(1−ρ)w 16.11
Trata-se de uma distribuição exponencial truncada. Seu q-percentil é dado por
wq=
1
μ(1−ρ)
ln(
100ρ
100−q
) 16.12
Esta fórmula se aplica somente se q é maior do que 100(1-ρ) sendo os demais percentis 
não nulos. Isto pode ser indicado pela equação:
Modelagem e Simulação Discreta 229
wq=max {0 ,
E [w ]
ρ ln (10ρ)} 16.13
O número médio de pacotes na Fila é dado por
E[nq]=∑
n=1
∞
(n−1) pn=∑
n=1
∞
(n−1)(1−ρ)ρn= ρ2
1−ρ
16.14
Modelagem e Simulação Discreta 230
17 GVA PELO MÉTODO DA INVERSA
Uma grande desvantagem do Método da Inversa aplicado na Geração de Variáveis 
Aleatórias é que seu uso esta limitado a distribuições que possuem FDA inversível como, por 
exemplo, as distribuições Exponencial, Logística e Pareto, Gumbel ou Valores Extremos e 
Weibull. O Quadro 17.1 lista estas distribuições de probabilidade, suas fdp, fda e x, a técnica 
de GVA destas fda, onde u ~ U(0,1).
Quadro 17.1 Distribuições de probabilidade, fdp, fda e x, a técnica de GVA destas fda, onde u 
~ U(0,1).
Distribuição f(x) F(x) x
Exponencial aexp(−a x) 1−exp (−a x) −a ln (u)
Logística
1
4 s
sech2( x−m
2 s
)
1
1+exp [−( x−m
s
)]
m−s ln ( 1
u
−1)
Pareto ( 1
x
)
a 1
a−1
(1− 1
xa−1
) [ 1
1−u (a−1)
]
1
a−1
Valores Extremos
1
s
exp[− x−m
s
−exp(− x−m
s
)] exp[−exp (− x−m
s
)] m−s ln [−ln(u)]
Weibull a
b
( x
b
)
a−1
exp[−( x
b
)
a
] 1−exp [−( x
b
)
a
] b[−ln(u)]
1
a
Nos tópicos abaixo estão descritos os procedimentos matemáticos para Gerar Variáveis 
Aleatórias das fdp Exponencial, Logística e Pareto, Gumbel ou Valores Extremos e Weibull, 
listadas no O Quadro 17.1.
17.1 GVA da Distribuição de Probabilidade Exponencial
Modelagem e Simulação Discreta 231
Uma variável aleatória x segue a distribuição de probabilidade Exponencial se sua 
função densidade de probabilidade é dada pela equação f (x)=λ exp(−λ x) , com x ≥ 0 e λ > 
0.
A função de distribuição acumulada da distribuição Exponencial é dada por:
F(x )=∫
0
x
1
s
λ exp(−λ x)=1−exp(−λ x)
Fazendo F(x) = u, onde u ~ U(0,1), obtém-se:
u=1−exp(−λ x) ⇔ exp(−λ x)=1−u ⇔ −λ x=ln (1−u) ⇔ x=−ln(1−u)/λ .
Como (1-u) ~ U(0,1) e u ~ U(0,1) são intercambiáveis, tem-se que x=−ln(u)/λ .
Conclusão: x=−ln(u)/λ uma variável aleatória com distribuição de probabilidade 
Exponencial, f (x)=λ exp(−λ x) de parâmetro λ, usando números aleatórios u com distribuição 
uniforme, u ~ U(0,1).
17.2 GVA da Distribuição de Probabilidade de Valores 
Extremos
Uma variável aleatória x segue a distribuição de probabilidade de Valores Extremos se 
sua função densidade de probabilidade é dada pela equação:
f (x)=1
s
exp [− x−m
s
−exp (− x−m
s
)] , x, m, s ∊ ℝ, com s > 0; m é o parâmetro de localização 
e s é o parâmetro de escala.
A função de distribuição acumulada da distribuição de de Valores Extremos é dada por:
F(x )=∫
−∞
x
1
s
exp[ x−m
s
−exp( x−m
s
)]dx=exp [−exp(− x−m
s
)]
Fazendo F(x) = u, onde u ~ U(0,1), obtém-se:
u=exp[−exp(− x−m
s
)] ⇔ ln(u)=−exp(− x−m
s
) ⇔ ln [−ln(u)]=− x−m
s
⇔ x=m−s ln [−ln(u)] .
Conclusão: x=m−s ln [−ln(u)] uma variável aleatória com distribuição de probabilidade 
de Valores Extremos, f (x)=1
s
exp [− x−m
s
−exp (− x−m
s
)] e parâmetros m e s, usando números 
aleatórios u com distribuição uniforme, u ~ U(0,1).
17.3 GVA da Distribuição de Probabilidade Logística
Modelagem e Simulação Discreta 232
Uma variável aleatória x segue a distribuição de probabilidade Logística se sua função 
densidade de probabilidade é dada pela equação:
f (x)= 1
4 s
sech2( x−m
2 s
) , x, m, s ∊ ℝ, com s >0; m é o parâmetro de localização e s é o 
parâmetro de escala.
A função de distribuição acumulada da distribuição de Pareto é dada por:
F(x )=∫
−∞
x
1
4 s
sech2( x−m
2 s
)dx= 1
1+exp [−( x−m
s
)]
Fazendo F(x) = u, onde u ~ U(0,1), obtém-se:
u= 1
1+exp [−( x−m
s
)]
⇔ 1+exp[−(x−m
s
)]=1
u
⇔ exp[−( x−m
s
)]=1
u
−1 ⇔ −( x−m
s
)=ln ( 1
u
−1) ⇔
x=m−s ln( 1
u
−1) .
Conclusão: x=m−s ln( 1
u
−1) uma variável aleatória com distribuição de probabilidade 
Logística, f (x)= 1
4 s
sech2( x−m
2 s
) de parâmetros m e s, usando números aleatórios u com 
distribuição uniforme, u ~ U(0,1).
17.4 GVA da Distribuição de Probabilidade de Pareto
Uma variável aleatória x segue a distribuição de probabilidade de Pareto se sua função 
densidade de probabilidade é dada pela equação f (x)=( 1
x
)
a
definida para x ≥ 1. Onde a > 1 
é um parâmetro de forma, que é conhecido como índice de cauda.
A função de distribuição acumulada da distribuição de Pareto é dada por:
F(x )=∫
1
x
( 1
x
)
a
dx= 1
a−1
(1− 1
xa−1 )
Fazendo F(x) = u, onde u ~ U(0,1), obtém-se:
u= 1
a−1
(1− 1
xa−1
) ⇔ u(a−1)=1− 1
xa−1
⇔
1
xa−1
=1−u (a−1) ⇔ xa−1= 1
1−u(a−1)
⇔
x=[ 1
1−u(a−1)
]
1
a−1 .
Modelagem e Simulação Discreta 233
Conclusão: x=[ 1
1−u(a−1)
]
1
a−1 é uma variável aleatória com distribuição de 
probabilidade de Pareto, f (x)=( 1
x
)
a
de parâmetros a, usando números aleatórios u com 
distribuição uniforme, u ~ U(0,1).
17.5 GVA da Distribuição de Probabilidade Weibull
Uma variável aleatória x segue a distribuição de probabilidade Weibull se sua função 
densidade de probabilidade é dada pela equação f (x)=a
b
( x
b
)
a−1
exp [−( x
b
)
a
] definida para x ≥ 0. 
Onde o parâmetro a ≥ 0 é adimensional, o parâmetro de forma, variações no valor de a 
alteram drasticamente o comportamento da distribuição. O parâmetro b ≥ 0 é medido na 
mesma unidade que x, e está associado à escala do gráfico da função, ou seja, variações no 
seu valor, enquanto k é mantido constante, causam a compressão ou expansão do gráfico.
A função de distribuição acumulada da distribuição de Weibull é dada por:
F(x )=∫
0
x
a
b
( x
b
)
a−1
exp [−( x
b
)
a
]dx=1−exp [−( x
b
)
a
]
Fazendo F(x) = u, onde u ~ U(0,1), obtém-se:
u=1−exp[−( x
b
)
a
] ⇔ 1−u=exp[−( x
b
)
a
] ⇔ ln(1−u)=−( x
b
)
a
⇔ a√−ln(1−u)= x
b
⇔ x=b a√−ln(1−u) .
Como (1-u) ~ U(0,1) e u ~ U(0,1) intercambiáveis, tem-se que x=b a√−ln(u) .
Conclusão: x=b a√−ln(u) é uma variável aleatória com distribuição de probabilidade 
Weibull f (x)=a
b
( x
b
)
a−1
exp [−( x
b
)
a
] , de parâmetros a e b, usando números aleatórios u com 
distribuição uniforme, u ~ U(0,1).
Modelagem e Simulação Discreta 234
18 REFERÊNCIAS
Averill, M. L. Simulation Modeling and Analysis. Pearson Education, 2006.
Bandyopadhyay, Susmita; Bhattacharya, Ranjan. Discrete and Continuous Simulation: Theory 
and Practice. CRC Press, 2014. 344p.
Brown, Walter E. Random Number Generation in C++11. 2013. Disponível em: 
<http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2013/n3551.pdf>. Acesso em: 20 Dez 
2013.
Bussab, W. O.; Morettin, P. A. Estatística Básica. 5ed. São Paulo: Saraiva, 2002. 526p.
Catalunha, Márcio José; Sediyama, Gilberto Chohaku; Leal, Brauliro Gonçalves; Soares, Carlos 
Pedro Boechat; Ribeiro, Aristides. Aplicação de cinco funções densidade de probabilidade a 
séries de precipitação pluvial no Estado de Minas Gerais. Revista Brasileira de 
Agrometeorologia, v. 10, n. 01, p. 153-162, 2002.
Chen, Ken. Performance Evaluation by Simulation and Analysis with Applications to Computer 
Networks. John Wiley & Sons, 2015. 226p.
Chung, Christopher A. Simulation modeling handbook: a practical approach. Boca Raton, 
Florida: CRC Press LLC, 2004. 574p.
cppreference. Pseudo-random number generation. Disponível em: 
<http://en.cppreference.com/w/cpp/numeric/random>. Acesso em: 20 Dez 2013.
Domo 8. Data Never Sleeps 8.0. Disponível em: 
<https://www.domo.com/learn/infographic/data-never-sleeps-8>. Acesso em: 09 Dez 2021.
Domo 9. Data Never Sleeps 9.0. Disponível em: 
<https://www.domo.com/learn/infographic/data-never-sleeps-9>. Acesso em: 09 Dez 2021.
Epperson, James F. An introduction to numerical methods and analysis. 2nd ed. Hoboken, New 
Jersey: John Wiley & Sons, Inc., 2013. 591p.
Modelagem e Simulação Discreta 235
Forbes, Catherine; Evans, Merran; Hastings, Nicholas; Peacock, Brian. Statistical distributions. 
4th ed. Hoboken, New Jersey: John Wiley & Sons, Inc., 2011. 212p.
Freitas Filho, Paulo José. Introdução à Modelagem e Simulação de Sistemas com Aplicações 
Arena. 2a ed. Florianópolis: Visual Books, 2008. 372p.
Gentle, J. E. Handbook of Computational Statistics. Heidelberg: Springer, 2004. 900p. 
(ISBN/ASIN: 3540404643, ISBN13: 9783540404644).
Hines, W. W. et al. Estatística Aplicada e Probabilidade para Engenheiros. LTC, 2003.
Hirata, Miguel, H. Uma introdução ao aproveitamento da energia eólica. Rio de Janeiro, Brazil: 
Proceedings of ENCIT 2004, ABCM, 2004. Disponível em 
<http://www.abcm.org.br/anais/encit/2004/artigos/invited/CIT04-IL14.pdf>. Acesso em: 19 
Mai 2015.
Hull, T. E.; Dobell, A. R. Random Number Generators. SIAM Review, 1962, Vol. 4, No. 3: pp. 
230-254. (Disponível em52: <https://www.jstor.org/stable/2027716>. Acesso em: 04 Set 2019.
Jain, R. The Art of Computer Systems Performance Analysis: Techniques for Experimental 
Design, Measurement, Simulation, and Modeling. Wiley-Interscience, 1991.
Kroese, Dirk P.; Chan, Joshua C. C. Statistical Modeling and Computation. Springer: New York, 
2014.
L'Ecuyer, Pierre. L'Ecuyer's Combined Recursive Generator, 2007. Disponível em: 
<http://www.democritos.it/activities/IT-MC/ACML-4.0.1/L_0027Ecuyer_0027s-Combined-
Recursive-Generator.html>. Acesso em: 10 Mar 2011.
L'Ecuyer, Pierre. MRG32k3a.c. Disponível em: 
<http://simul.iro.umontreal.ca/rng/MRG32k3a.c>. Acesso em: 24 Mar 2020.
Larson, Ron; Farber, Betsy. Estatística Aplicada. 4ed. São Paulo: Pearson Prentice Hall, 2010, 
637p.
Leemis, Larry. Univariate Distribution Relationships. Disponível em: 
<http://www.math.wm.edu/~leemis/chart/UDR/UDR.html>. Acesso em: 13 Mai 2015.
Leite, Maysa Lima; Virgens Filho, Jorim Sousa. Ajuste de modelos de distribuição de 
probabilidade a séries horárias de velocidade do vento para o município de Ponta Grossa, 
Estado do Paraná. Acta Scientiarum. Technology Maringá, v.33, n.4, p.447-455, 2011.
Marsaglia, George; Tsang, Wai Wan; Wang, Jingbo. Evaluating Kolmogorov’s Distribution. 
Disponível em: <http://www.jstatsoft.org/v08/i18/paper?ev=pub_ext_btn_xdl>. Acesso em: 13 
Mai 2015.
Mersenne Twister. What is Mersenne Twister (MT)?. Disponível em: 
<http://www.math.sci.hiroshima-u.ac.jp/~m-mat/MT/ewhat-is-mt.html>. Acesso em: 10 Mar 
2011.
52 <http://chagall.med.cornell.edu/BioinfoCourse/PDFs/Lecture4/random_number_generator.pdf>
Modelagem e Simulação Discreta 236
Mor, Harchol-Balter. Performance modeling and design of computer systems: queueing theory 
in action. Cambridge University Press, New York, 2013. 574p. 
NIST. NIST Special Publication 800-22 Revision 1a: A Statistical Test Suite for Random and 
Pseudorandom Number Generators for Cryptographic Applications. 2010. Disponível em: 
<http://csrc.nist.gov/publications/nistpubs/800-22-rev1a/SP800-22rev1a.pdf>. Acesso em: 20 
Mai 2016.
Polyanin, Andrei D.; Manzhirov, Alexander V. Handbook of Mathematics for Engineers and 
Scientists. New York: Chapman & Hall/CRC, 2007. 1509p.
Ross, Sheldon M. Simulation. 5th ed. Elsevier: Amsterdam, 2013. 310p.
Spiegel, Murray R., Schiller, John J, Srinivasan, R. Alu. Probability and statistics. 4ed. New York: 
McGraw-Hill, 2013. 424p.
Simard, Richard; L’Ecuyer, Pierre. Computing the Two-Sided Kolmogorov-Smirnov Distribution. 
Disponível em: <http://www.iro.umontreal.ca/~lecuyer/myftp/papers/ksdist.pdf>. Acesso em: 
04 Abr 2015.
Sun Microsystems. Sun Fire™ X4150, X4250, and X4450 Server Architecture. September 
2008. Disponível: <https://docplayer.net/7413100-Sun-fire-x4150-x4250-and-x4450-server-
architecture-breakthrough-density-using-sun-and-intel-technology.html>. Acesso em: 22 Jul 
2021.
Thom, H. C. S. A note on the gamma distribution. Monthly Weather Review, Washington, v.86, 
p.117-122, 1958.
Zwillinger, Daniel; Kokoska, Stephen. Standard probabilityand statistics tables and formulary 
- Student Edition. CRC Press: Boca Raton, 2000. 215p.
Modelagem e Simulação Discreta 237
Fonte: https://image.flaticon.com/icons/png/512/47/47443.png
As fragatas são aves de grande porte, com asas compridas e estreitas que representam a menor 
superfície de asa por unidade de peso do mundo das aves. Têm cerca de 1 metro de 
comprimento, mais de dois de envergadura e uma cauda longa e bifurcada. As 
fragatas não conseguem andar em terra, nadar nem levantar voo de uma superfície 
plana. São, no entanto, aves extremamente rápidas em voo sobre o mar ou sobre 
outras aves.
	1 Introdução
	1.1 Sistema
	1.2 Modelo
	1.3 Dinâmica Temporal de Sistemas Computacionais
	1.4 Simulação
	1.5 Sistemas de Fila
	1.6 Simulação de Sistemas de Eventos Discretos
	1.7 Simulação de Sistemas Computacionais
	1.8 Etapas de um Estudo de Simulação
	1.9 Revisão
	1.10 Questões 1
	1.11 Questões 2
	1.12 Exercícios
	2 Sistemas de Fila
	2.1 Sistemas de Fila M/M/1
	2.2 Revisão
	2.3 Questões
	3 Modelo Analítico de Sistemas de Fila
	3.1 Modelo de Sistemas de Fila M/M/1
	3.2 Modelo Analítico de Sistemas de Fila M/M/1
	3.3 Revisão
	3.4 Questões
	3.5 Exercícios
	4 Modelo Conceitual de Sistemas de Fila
	4.1 Dados de Entrada para Simulação
	4.2 Valores Iniciais da Simulação
	4.3 Cálculo de cpf
	4.4 Cálculo de eps
	4.5 Cálculo de sps
	4.6 Estatísticas do Modelo Conceitual de Sistemas de Fila
	4.7 Algoritmo para Calcular nf
	4.8 Algoritmo para Calcular U
	4.9 Sumário do Modelo Conceitual de Sistemas de Filas
	4.10 Revisão
	4.11 Questões
	4.12 Exercícios
	5 Modelo Computacional de Sistemas de Fila
	5.1 Técnica para Gerar ic e ts
	5.2 Software SF.MM1.cpp
	5.3 Revisão
	5.4 Questões
	5.5 Exercícios
	6 Verificação e Validação de Modelos
	6.1 Técnicas de Validação de Modelo
	6.2 Técnicas de Verificação de Modelos
	6.3 Revisão
	6.4 Questões
	6.5 Exercícios
	7 Análise de Resultados Simulados
	7.1 Remoção de Transientes
	7.1.1 Estimação por Intervalos de Confiança
	7.1.2 Método das Médias de Lotes
	7.1.3 Método de Replicação Independente
	7.2 Critério de Parada
	7.2.1 Intervalo de Confiança como Critério de Parada
	7.2.2 N como Critério de Parada
	7.3 Que Nível de Confiança Estatística Usar
	7.4 Software SF.MM1-ML-RI.cpp
	7.5 Revisão
	7.6 Questões
	7.7 Exercícios
	8 Simulação de Sistemas Computacionais
	8.1 Modelo de Rede de Sistemas de Fila (RSF)
	8.2 Modelo Conceitual de RSF
	8.3 Valores Iniciais da Simulação de RSF
	8.4 Roteamento do Primeiro Pacote (p=0)
	8.5 Roteamento dos Demais Pacotes (p>0)
	8.6 Revisão das RSF
	9 Modelo Computacional de Redes de Sistemas de Filas
	9.1 Sistema Cliente/Servidor Web em uma Camada Física
	9.2 Sistema Cliente/Servidor Web em duas Camadas Físicas
	9.3 Sistema Cliente/Servidor Web em três Camadas Físicas
	9.4 Simulação de Sistemas de Hardware
	9.5 Revisão
	9.6 Exercícios
	10 Geração de Números Aleatórios
	10.1 Geradores Congruentes Lineares (GCL)
	10.2 Aplicação do GCL
	10.3 Sementes para o GCL
	10.4 GCL de uso geral
	10.5 Números Aleatórios do GNU C
	10.6 Composição de Geradores
	10.7 Geradores Tausworthe
	10.8 Outros Geradores
	10.9 Classe clGNA
	10.10 Teste Empíricos de GNA
	10.10.1 Testes Empíricos
	10.11 Testes Teóricos
	10.11.1 GNA com Distribuição Uniforme
	10.11.2 GNA Estatisticamente Independente
	10.11.3 Custo Computacional de GNA
	10.11.4 Algoritmo para testes teóricos
	10.12 Questões
	10.13 Exercícios
	11 Geração de Variáveis Aleatórias
	11.1 Método da Inversa da FDA
	11.2 Método da Convolução
	11.3 Método da Composição
	11.4 Método da Aceitação Rejeição
	11.5 Gerar FDA
	11.6 Qualidade na Geração de Variáveis Aleatórias
	11.7 Algoritmos para Gerar Variáveis Aleatórias
	11.8 Gerar Processos de Chegada
	11.9 Questões
	11.10 Exercícios
	12 Seleção de Distribuições de Probabilidade
	12.1 Independência de Observações
	12.2 Distribuições de Probabilidade Úteis
	12.3 Estimação de Parâmetros
	12.3.1 Método da Máxima Verossimilhança
	12.3.2 Método dos Mínimos Quadrados
	12.4 Estimativa dos Parâmetros das FDP
	12.4.1 Estimativa dos parâmetros da fdp Exponencial
	12.4.2 Estimativa dos parâmetros da fdp Beta
	12.4.3 Estimativa dos parâmetros da fdp Gamma
	12.4.4 Estimativa dos parâmetros da fdp Weibull
	12.5 Identificação da Distribuição Estatística
	12.5.1 Teste Chi-Quadrado (CQ)
	12.5.2 Testes CQ para fdp Beta
	12.6 Modelos para Processos de Chegada
	12.7 Gerando Processos de Chegada
	12.8 Testando Homogeneidade de Amostras
	12.9 Questões
	12.10 Exercícios
	13 Recursos do C++ para a Simulação
	14 Redução da Variância
	14.1 Números Aleatórios Comuns
	14.2 Variáveis Antitéticas
	14.3 Métodos Estatísticos para Comparar Resultados Simulados
	14.3.1 Teste para Média Zero
	14.3.2 Observações Pareadas
	14.3.3 Observações não Pareadas
	14.4 Questões
	14.5 Exercícios
	15 Softwares para Simulação Sistemas de Fila
	15.1 Dicionário de Dados dos Softwares
	15.2 SF.MM1.cpp
	15.3 SF.MM1-ML-RI.cpp
	15.4 RSF.MM1.cpp
	15.5 RSF.MM1-ML-RI.cpp
	16 Modelo Analítico de Sistemas de Fila M/M/1
	17 GVA pelo Método da Inversa
	17.1 GVA da Distribuição de Probabilidade Exponencial
	17.2 GVA da Distribuição de Probabilidade de Valores Extremos
	17.3 GVA da Distribuição de Probabilidade Logística
	17.4 GVA da Distribuição de Probabilidade de Pareto
	17.5 GVA da Distribuição de Probabilidade Weibull
	18 Referências