UNIVERSIDADE FEDERAL DO VALE DO SÃO FRANCISCO

COLEGIADO DE ENGENHARIA DE COMPUTAÇÃO

MAURÍCIO SILVA SOARES

Análise de Sistema de Fila com QSN-RI e Análise do Valor Médio

Juazeiro, 2019
 MAURÍCIO SILVA SOARES

Análise de Sistema de Fila com QSN-RI e Análise do Valor Médio

Relatório técnico apresentado como

requisito parcial para obtenção de
aprovação na disciplina de Análise de
Desempenho de Sistemas, no curso de
Engenharia de Computação, na
Universidade Federal do Vale do São
Francisco.

Juazeiro, 2019

1
 RESUMO

Este trabalho faz uma comparação das análises de um mesmo sistema de fila,
utilizando-se das técnicas QSN-RI e Análise do Valor Médio. Para a aplicação das
técnicas utilizou-se de algoritmos desenvolvidos em C++, em ambas. Sendo o
sistema de filas o mesmo para as duas técnicas. Esse sistema é composto por um
roteador, um notebook, um switch, um servidor de backup e uma impressora. Então
fez-se a comparação entre os tempos de utilização, tamanho das filas e tempo de
resposta para cada técnica de análise.

Palavras-chave: Sistema de filas. QSN-RI. Análise do Valor Médio.

2
 LISTA DE FIGURAS

Figura 1 - Formato da rede e seus componentes. N

3
 LISTA DE TABELAS

Tabela 1 - Desempenho dos equipamentos em MB e Mb. N

Tabela 2 - Dados do sistema. N
Tabela 3 - Tamanho médio das filas em cada equipamento usando QSN-RI. N
Tabela 4- Sumarização dos dados da Tabela 3.
N
Tabela 5 - Tempo de espera médio em cada equipamento usando QSN-RI. N
Tabela 6 - Sumarização dos dados da Tabela 5. N
Tabela 7 - Utilização média de cada equipamento usando QSN-RI. N
Tabela 8 - Sumarização dos dados da Tabela 7. N
Tabela 9 - Tamanho médio das filas em cada equipamento usando AVM. N
Tabela 10 - Tempo de espera médio em cada equipamento usando AVM. N
Tabela 11 - Utilização média de cada equipamento usando AVM. N

4
 SUMÁRIO

1. INTRODUÇÃO 6
1.1 CÁLCULOS 6

2. RESULTADOS 8
2.1 QSN-RI 8
2.2 ANÁLISE DO VALOR MÉDIO 12

3. ANÁLISES E GRÁFICOS 14

REFERÊNCIAS 15

5
1. INTRODUÇÃO
Este trabalho faz uma comparação entre dois métodos para análise de
sistema de filas. As técnicas utilizadas são o QSN-RI e Análise do Valor Médio. Para
aplicação dessas técnicas, utilizou-se de algoritmos desenvolvidos em C++, os
quais podem ser encontrados em anexo neste documento.
A rede em análise é composta por cinco elementos, são eles: um roteador,
um notebook, um switch, um servidor de backup e uma impressora. Para facilitar no
desenvolvimento de rede e sua análise atribui-se uma aplicação para a mesma, que
tem como objetivo receber arquivos, mais especificamente fotos, podendo ser
pacotes de documentos de texto, então os armazena no computador
central(notebook) responsável pelos downloads, criam-se cópias de backup e então
as imprime. Uma rede como essas pode ser aplicada em uma gráfica por
exemplo(ver Figura 1).

Figura 1 - Formato da rede e seus componentes.

1.1 CÁLCULOS
Para a realização da simulação, faz-se necessário saber o caminho do
pacote de dados. Para o caso aqui discutido, a sequência é a seguinte: 0, 1, 0, 2, 3,
2, 4. O pacote contém 5 fotos para backup e impressão, cada foto com 5MB, tendo
assim um tamanho total de 25MB, o que resulta em 200Mb.
Para o cálculo de iat(interarrival time) considerou-se que a cada minuto
chegavam seis documentos, resultando assim em um iat de 10s/doc. Como o único
iat necessário é o inicial, o próximo passo é calcular o st(service time) para cada
componente da rede. Para isso utiliza-se como base os valores da tabela a seguir
(Tabela 1):

6
Tabela 1 - Desempenho dos equipamentos em MB e Mb.
EQUIPAMENTO DESEMPENHO

Roteador Wireless 150Mbps - 1 antena externa Mymax 150Mbps*

TOSHIBA MQ01ABD100 (HD do notebook) 74MBs

592Mbps

Switch de mesa TP-Link TLSF1005D 5 portas 10/100Mbps 10Mbps

- Cinza

Samsung HD103SJ (HD backup) 138MBs

1104Mbps

Impressora Samsung SL M 4075 FR PROXPRESS 40ppm

multifuncional 40*40=1600Mbpm
26.666Mbps
*Velocidade média para WIFI e cabo

Assim podemos obter os seguintes valores apresentados na Tabela 2:

Tabela 2 - Dados do sistema.

QS EQUIPAMENTO st(s/tarefa) Visitas

0 Roteador 1.33333 2

1 Notebook 0.337837 1

2 Switch 2 2

3 Backup 0.18115942 1

4 Impressora 7.5 1

7
2. RESULTADOS
A partir das informações anteriores e dos valores calculados, faz-se possível
executar as análises através do QSN-RI e Análise do Valor Médio. Então, os
resultados entregues pelos algoritmos executados poderão ser comparados.

2.1 QSN-RI
Nas tabelas seguintes, estão listados os resultados utilizando o algoritmo QSN-RI,
para 10 repetições do experimento. As tabelas estão dispostas na organização: primeiro os
resultados do experimento e na tabela seguinte, os cálculos estatísticos, para os resultados
de tamanho médio da fila(E[nq]), tempo médio de espera na fila(E[w]), e utilização para
cada equipamento que compõe o sistema.
Os dados aqui representados são o tamanho médio da fila, E[nq]​n (Tabela 3), na
Tabela 4 estão as análises estatísticas para esses dados.

Tabela 3 - Tamanho médio das filas em cada equipamento usando QSN-RI.

R E[nq]​0 E[nq]​1 E[nq]​2 E[nq]​3 E[nq]​4

1 0,172 0,042 0,313 0,022 2,738

2 0,185 0,049 0,317 0,020 2,421

3 0,169 0,033 0,287 0,015 2,308

4 0,174 0,029 0,307 0,017 2,835

5 0,186 0,043 0,306 0,011 2,158

6 0,178 0,030 0,306 0,018 2,349

7 0,173 0,041 0,311 0,018 3,044

8 0,175 0,035 0,308 0,016 3,689

9 0,176 0,037 0,295 0,013 3,167

10 0,176 0,036 0,293 0,021 3,071

Tabela 4- Sumarização dos dados da Tabela 3.

Dados Resultados

E[nq]​0 E[nq]​1 E[nq]​2 E[nq]​3 E[nq]​4

Média 0,1764 0,0375 0,3043 0,0171 2,778

aritmética da

8
amostra

Média 0,1763266 0,0370365 0,30416325 0,0167579 2,7418473

geométrica da 09283122 32057956 4674726 6651114 6242486
amostra

Média 0,1762542 0,0365819 0,30402486 0,0163932 2,7068205

harmônica da 03210062 17263286 3309307 52673652 4275526
amostra

Mediana da 0,1755 0,0365 0,3065 0,0175 2,7865

amostra(ordena
da)

Moda da 0,176 -- 0,306 0,018 --

amostra

Variância da 2,9155555 3,9166666 9,13444444 1,21E-05 0,2288317

amostra 5555555E 6666667E 444444E-0 77777778
-05 -05 5

Desvio padrão 0,0053995 0,0062583 0,00955742 0,0034785 0,4783636

da amostra 88461684 27785173 8756964 05426185 45961707

Coeficiente de 0,0001652 0,0010444 0,00030017 0,0007076 0,0823728

variação 80927186 44444444 8917004 02339181 50171986

Amplitude 0,013 0,02 0,03 0,011 1,531

Percentil 10% 0,1717 0,0299 0,2924 0,0128 2,293

Percentil 90% 0,1851 0,0436 0,3134 0,0211 3,2192

Semi-IQR 0,002125 0,004125 0,00625 0,002125 0,348625

Desvio médio 0,00396 0,005 0,00758 0,0027 0,3832

absoluto

Também é possível observar (Tabela 5), os tempos médio de espera na fila

para as tarefas, E[w]​n​, seguido por sua análise estatística na Tabela 6.

Tabela 5 - Tempo de espera médio em cada equipamento usando QSN-RI.

R E[w]​0 E[w]​1 E[w]​2 E[w]​3 E[w]​4

1 0,202 0,015 0,509 0,004 21,180

2 0,223 0,015 0,505 0,004 17,800

3 0,198 0,011 0,453 0,003 17,168

9
4 0,194 0,010 0,498 0,004 21,763

5 0,220 0,014 0,489 0,002 15,267

6 0,211 0,010 0,497 0,004 16,824

7 0,194 0,014 0,489 0,004 22,547

8 0,203 0,014 0,484 0,002 29,385

9 0,204 0,013 0,473 0,002 24,151

10 0,206 0,013 0,468 0,004 22,608

Tabela 6 - Sumarização dos dados da Tabela 5.

Dados Resultados

E[w]​0 E[w]​1 E[w]​2 E[w]​3 E[w]​4

Média 0,2055 0,0129 0,4865 0,0033 20,8693

aritmética da
amostra

Média 0,2052874 0,0127639 0,48621272 0,0031568 20,496887

geométrica da 23685407 35517201 0407248 73059995 207301
amostra

Média 0,2050785 0,0126202 0,48592147 0,003 20,138866

harmônica da 12975059 98382013 1595054 3928248
amostra

Mediana da 0,2035 0,0135 0,489 0,004 21,4715

amostra(ordena
da)

Moda da 0,194 0,014 0,489 0,004 --

amostra

Variância da 9,8722222 3,6555555 0,00030627 9E-07 17,876681

amostra 2222222E 5555556E 7777778 3444444
-05 -06

Desvio padrão 0,0099359 0,0019119 0,01750079 0,0009486 4,2280824

da amostra 05707193 5071996 3632798 83298051 6660876

Coeficiente de 0,0004804 0,0002833 0,00062955 0,0002727 0,8566018

variação 00108137 76399655 3500057 27272727 67070024

Amplitude 0,029 0,005 0,056 0,002 14,118

10
Percentil 10% 0,194 0,01 0,4665 0,002 16,6683

Percentil 90% 0,2203 0,015 0,5054 0,004 24,6744

Semi-IQR 0,005375 0,00125 0,011 0,000875 2,633375

Desvio médio 0,0076 0,00154 0,0136 0,00084 3,28364

absoluto

Já na Tabela 7, estão dispostos os tempos de utilização de cada

equipamento do sistema, U​n​, e logo após, na Tabela 8, está a sumarização dos
dados estatísticos para a esses resultados.

Tabela 7 - Utilização média de cada equipamento usando QSN-RI.

R U​0 U​1 U​2 U​3 U​4

1 0,134 0,035 0,198 0,018 0,746

2 0,133 0,036 0,202 0,018 0,726

3 0,132 0,035 0,196 0,018 0,729

4 0,133 0,034 0,200 0,018 0,758

5 0,133 0,035 0,196 0,017 0,714

6 0,134 0,034 0,201 0,018 0,755

7 0,132 0,033 0,201 0,018 0,734

8 0,134 0,035 0,201 0,019 0,789

9 0,132 0,034 0,195 0,018 0,740

10 0,134 0,035 0,200 0,019 0,795

Tabela 8 - Sumarização dos dados da Tabela 7.

Dados Resultados

U​0 U​1 U​2 U​3 U​4

Média 0,1331 0,0346 0,199 0,0181 0,7486

aritmética da
amostra

Média 0,1330974 0,0345906 0,19898537 0,0180919 0,7481848

geométrica da 05882553 99249893 0359244 91119555 77193306
amostra

11
Média 0,1330948 0,0345813 0,19897068 0,0180839 0,7477754
harmônica da 09735565 45857489 4872134 81337481 89435852
amostra

Mediana da 0,133 0,035 0,2 0,018 0,743

amostra(ordena
da)

Moda da 0,134 0,035 0,201 0,018 --

amostra

Variância da 7,6666666 7,1111111 6,44444444 3,2222222 0,0007000

amostra 6666668E 1111113E 444446E-0 2222221E- 44444444
-07 -07 6 07

Desvio padrão 0,0008755 0,0008432 0,00253859 0,0005676 0,0264583

da amostra 95035771 74042712 1035288 46212198 53018365

Coeficiente de 5,7600801 2,0552344 3,23841429 1,7802332 0,0009351

variação 4024544E 2517663E 369068E-0 7194597E- 38183869
-06 -05 5 05

Amplitude 0,002 0,003 0,007 0,002 0,081

Percentil 10% 0,132 0,0339 0,1959 0,0179 0,7248

Percentil 90% 0,134 0,0351 0,2011 0,019 0,7896

Semi-IQR 0,000875 0,0005 0,00225 0 0,0135

Desvio médio 0,00072 0,00068 0,0022 0,00036 0,02052

absoluto

2.2 ANÁLISE DO VALOR MÉDIO

Os dados de saída do algoritmo da Análise do Valor Médio, encontram-se
nas seguintes tabelas(9,10,11).
Os resultados para essa análise, são estáticos, ou seja, independente de
quantas vezes o experimento seja repetido, os resultados serão os mesmos.
Foram feitas 15000 repetições para o experimento, e ao final calculada a
média desses resultados, que podem ser encontradas ao fim de cada tabela.

Tabela 9 - Tamanho das filas em cada equipamento usando AVM.

n nq​0 nq​1 nq​2 nq​3 nq​4

1 0,143 0,0181 0,214 0,0097 0,401

12
2 0,266 0,03 0,423 0,0159 0,916

3 0,362 0,0373 0,611 0,0197 1,54

4 0,431 0,0416 0,765 0,0219 2,26

5 0,478 0,0441 0,885 0,0232 3,07

6 0,508 0,0455 0,972 0,0239 3,93

7 0,527 0,0463 1,03 0,0243 4,85

8 0,538 0,0467 1,07 0,0245 5,79

9 0,544 0,0469 1,1 0,0246 6,75

10 0,547 0,047 1,12 0,0247 7,73

... ... ... ... ... ...

15000 0,552 0,0472 1,14 0,0248 15000

MÉDIA 0,5519 0,0471 1,1397 0,0247 7498,0315

Na seguinte tabela, temos os valores encontrados para o tempo de resposta

em cada equipamento, utilizando da Análise do Valor Médio (Tabela 7).

Tabela 10 - Tempo de resposta em cada equipamento usando AVM.

n r​0 r​1 r​2 r​3 r​4

1 1,33 0,338 2 0,181 7,5

2 1,52 0,344 2,43 0,183 10,5

3 1,69 0,348 2,85 0,184 14,4

4 1,82 0,35 3,22 0,185 19,1

5 1,91 0,352 3,53 0,185 24,5

6 1,97 0,353 3,77 0,185 30,5

7 2,01 0,353 3,94 0,185 37

8 2,04 0,353 4,07 0,186 43,8

9 2,05 0,354 4,15 0,186 50,9

10 2,06 0,354 4,2 0,186 58,2

13
... ... ... ... ... ...

15000 2,07 0,354 4,29 0,186 112000

MÉDIA 2,0698 0,3539 4,2894 0,1859 56236,4385

Tabela 11 - Utilização média de cada equipamento usando AVM.

n U​0 U​1 U​2 U​3 U​4

1 0,125 0,0178 0,176 0,0096 0,286

2 0,21 0,0291 0,297 0,0157 0,478

3 0,266 0,036 0,379 0,0194 0,607

4 0,301 0,04 0,434 0,0215 0,694

5 0,324 0,0422 0,469 0,0227 0,754

6 0,337 0,0435 0,493 0,0233 0,797

7 0,345 0,0442 0,508 0,0237 0,829

8 0,35 0,0446 0,518 0,0239 0,853

9 0,352 0,0448 0,524 0,024 0,871

10 0,354 0,0449 0,528 0,0241 0,885

... ... ... ... ... ...

15000 0,356 0,045 0,533 0,0242 1

MÉDIA 0,3559 0,0449 0,5329 0,0241 0,9994

14
3. ANÁLISES E GRÁFICOS
Ao analisar as utilizações do sistema U​n​, com a AVM, percebe-se que a
impressora, que é o equipamento final do sistema, possui alta utilização, chegando
em 100% e causando um estrangulamento. Mostrando que para altas quantidades
de usuários no sistema, ele tende a entrar em estrangulamento devido ao gargalo
causado pela impressora. Ao analisar a média das N repetições, encontra-se uma
utilização de 99,94%, o que é inaceitável considerando que as utilizações não
devem ultrapassar a casa dos 70%. Então, fica claro que o sistema não suporta tal
quantidade de tarefas, pois ao observar os resultados da Tabela 11, já na tarefa 6 a
utilização atinge 75,4%.
Observando a utilização da impressora, mas com os resultados do QSN-RI,
encontramos uma média mais baixa que no AVM, sendo igual a 74,86%, uma
diferença considerável, dado que no AVM o equipamento rapidamente se torna o
gargalo.
No gráfico seguinte(Figura 2), é possível ver o comportamento da utilização
da impressora com o aumento de requisições no sistema.

Figura 2 - Gráfico de utilização da impressora por número de usuários

Para esse gráfico o número de usuários foi limitado para 500, essa decisão
foi tomada porque ao utilizar de todo o espectro de requisições, a curva da utilização
não ficava evidente. Além do mais, desde muito antes desse valor, o equipamento já
se encontrava em 100% de utilização.

15
Gráfico do tempo de resposta da impressora por número de usuários

Assim como no gráfico da Figura 2, o gráfico anterior(Figura 3), teve seu

espectro de análise reduzido pelos mesmos motivos.

16
4. CONCLUSÕES
Percebe-se uma grande discrepância entre os resultados obtidos à partir das
análises. Ao se comparar a utilização média da impressora para cada algoritmo,
percebe que a utilização se mostra muito maior para o AVM.
Era esperado que os valores de utilização fossem altos, e que pela
quantidade de tarefas, em algum momento iria ocorrer um gargalo no sistema. O
que pode ser claramente visto no AVM, pois a partir da tarefa de número 2002, o
sistema já se encontrava em utilização máxima. Não é possível observar isso com o
QSN-RI, apenas comparar as médias entre cada um, as quais já se mostraram
discrepantes, e de acordo com o comportamento esperado o AVM se mostrou muito
mais condizente com uma situação real.
No quesito tempo de espera(r) é encontrado um valor maior que o dobro para
o tempo de fila(w). Mas isso é esperado, dado que o tempo de espera inclui o tempo
de serviço(st), de modo que r=w+s. Assim não é possível fazer uma comparação
direta entre esses resultados.
De qualquer modo, as dua técnicas de análise encontram o mesmo
problema, um gargalo na impressora. O que já era esperado, dado que este é um
dispositivo mecânico com alta latência. Para minimizar isso, recomenda-se a
aquisição de mais impressoras.

17
REFERÊNCIAS

LEAL, B. G. ​Avaliação de Desempenho de Sistemas​. 2016a. Disponível em: .

<​http://www.univasf.edu.br/~brauliro.leal/#​> Acesso em: 18 fev 2019.

LEAL, B. G. ​Modelagem e Simulação Discreta​. 2016.

18
 ANEXO

Código QSN-RI
//----------------------------------------------------------------
-------------
#​include​ ​<iostream>
#​include​ ​<cstdlib>
#​include​ ​<cmath>
#​include​ ​<ctime>
#​include​ ​<string>
#​include​ ​<vector>
#​include​ ​<algorithm>
#​include​ ​<fstream>
#​include​ ​<sstream>
//----------------------------------------------------------------
-------------
using​ ​namespace​ ​std​;
//----------------------------------------------------------------
--------------
typedef​ ​long​ ​double​ real;
//----------------------------------------------------------------
--------------
class​ ​clEvent​{
​public​:
​int​ nq;
real iat, st, at, bs, es, idt;
};
//----------------------------------------------------------------
--------------
class​ ​clQS​{
​public​:
real l, m, T, U, E[​7​], V[​7​];
​vector​<clEvent> Event;
};
//----------------------------------------------------------------
--------------
class​ ​clQSN​{
​private​:
​size_t​ s;
​vector​<​size_t​> S;
real ​F​ ( real );

19
 ​void​ O ​ pen​ ( ​size_t​, s ​ ize_t​ );
​void​ C ​ lose​ ( s
​ ize_t​, s ​ ize_t​ );
​void​ N ​ q​ ( v​ oid​ );

​public​:
​vector​<clQS> QS;

​void​ C ​ onfig​ ​ nt​, ​vector​<real>, ​int​, ​vector​<​size_t​> );

( i
​void​ S ​ imulate​ ( i ​ nt​ );
​void​ S ​ tatistic​( i ​ nt​ );
};
//----------------------------------------------------------------
--------------
void​ clQSN::Config( ​int​ qs, ​vector​<real> D, ​int​ s, ​vector​<​size_t​>
S ){
​this​->s = s;
​this​->S = S;
QS.clear();
​for​( ​int​ i = ​0​; i < qs; i++ ){
clQS x;
x.l = ​0.0​;
​if​( i == ​0​ ) x.l = D[i];
x.m = D[i+​1​];
QS.push_back(x);
}
}
real clQSN::F( real p ){
real u = (rand()+​1.0​)/(RAND_MAX+​2.0​); ​// u in (0,1)
​return​ -p*​log​(u);
}
void​ clQSN::Open( ​size_t​ i, ​size_t​ f ){
clEvent X, Xa;
Xa = QS[i].Event[ QS[i].Event.size()​-1​ ];
​if​( i == ​0​ ){
X.iat = F( QS[i].l );
X.st = F( QS[i].m );
X.at = Xa.at + X.iat;
X.bs = X.at > Xa.es ? X.at : Xa.es;
X.es = X.bs + X.st;
X.idt = X.es - Xa.es;
QS[i].Event.push_back(X);

20
// Nq(i);
}
Xa = QS[i].Event[ QS[i].Event.size()​-1​ ];
X.iat = Xa.idt;
X.st = F( QS[f].m );

Xa = QS[f].Event[ QS[f].Event.size()​-1​ ];
X.at = Xa.at + X.iat;
X.bs = X.at > Xa.es ? X.at : Xa.es;
X.es = X.bs + X.st;
X.idt = X.es - Xa.es;
QS[f].Event.push_back(X);
// Nq(f);
}
void​ clQSN::Close( ​size_t​ i, ​size_t​ f ){
clEvent X, Xa;

Xa = QS[i].Event[ QS[i].Event.size()​-1​ ];
X.iat = Xa.idt;
X.st = F( QS[f].m );

Xa = QS[f].Event[ QS[f].Event.size()​-1​ ];
X.at = Xa.at + X.iat;
X.bs = X.at > Xa.es ? X.at : Xa.es;
X.es = X.bs + X.st;
X.idt = X.es - Xa.es;
QS[f].Event.push_back(X);
// Nq(f);
}
void​ clQSN::Nq( ​void​ ){
​for​( ​size_t​ qs = ​0​; qs < QS.size(); qs++ ){
​for​( ​size_t​ e = ​1​; e < QS[qs].Event.size(); e++ ){
​size_t​ c = e​-1​;
QS[qs].Event[e].nq = ​0​;
​while​( QS[qs].Event[e].at < QS[qs].Event[c].es ){
QS[qs].Event[e].nq += ​1​;
c--;
}
}
}
}

21
void​ clQSN::Simulate( ​int​ N ){
​for​( ​size_t​ i = ​0​; i < s; i++ )
QS[ S[i] ].Event.push_back({​0​,​0​,​0​,​0​,​0​,​0​,​0​});
​for​( ​int​ e = ​1​; e < N; e++ ){
​for​( ​size_t​ i = ​1​; i < s; i++ ){
Open(S[i​-1​],S[i]);
​//Close(S[i-1],S[i]);
}
}
}
void​ clQSN::Statistic( ​int​ Ni ){
Nq();
​for​( ​size_t​ qs = ​0​; qs < QS.size(); qs++ ){
​size_t​ N = QS[qs].Event.size();
real x[​7​], Sx[​7​], Sxx[​7​];
​for​( ​size_t​ s = ​0​; s < ​7​; s++ )
Sx[s] = Sxx[s] = ​0.0​;
​for​( ​size_t​ e = Ni; e < N; e++ ){
clEvent X = QS[qs].Event[e];
x[​0​] = X.iat ;
x[​1​] = X.st ;
x[​2​] = X.nq ;
x[​3​] = X.idt ;
x[​4​] = X.bs-X.at; ​//w
x[​5​] = X.es-X.bs; ​//s
x[​6​] = X.es-X.at; ​//r
​for​( ​int​ s = ​0​; s < ​7​; s++ ){
Sx [s] += x[s];
Sxx[s] += x[s]*x[s];
}
}
QS[qs].T = QS[qs].Event[N​-1​].es-QS[qs].Event[Ni​-1​].bs;
QS[qs].U = Sx[​1​]/QS[qs].T;
​for​( ​int​ s = ​0​; s < ​7​; s++ ){
QS[qs].E[s] = Sx [s]/(N-Ni);
QS[qs].V[s] = Sxx[s]/(N-Ni)-QS[qs].E[s]*QS[qs].E[s];
}
}
}
string​ ​RI​( ​void​ ){
​int​ R = ​10​,

22
 N = ​15000​,
Ni = ​0.9​*N,
qs = ​5​,
s = ​7​;
​std​::​vector​<​size_t​> S;
S.reserve(​7​);

S.push_back(​0​);
S.push_back(​1​);
S.push_back(​0​);
S.push_back(​2​);
S.push_back(​3​);
S.push_back(​2​);
S.push_back(​4​);

​std​::​vector​<real> D;
D.reserve(​6​);

D.push_back(​10​);
D.push_back(​1.3333​);
D.push_back(​0.337837​);
D.push_back(​2​);
D.push_back(​0.18115942​);
D.push_back(​7.5​);

clQSN QSN[R];
​stringstream​ str;

str << fixed;

str.precision(​3​);

​for​( ​int​ r = ​0​; r < R; r++ ){

​cout​ << ​" Calculando RI: "​ << r << ​endl​;
srand( time(​NULL​)/(r+​1​) );
QSN[r].Config(qs,D,s,S);
QSN[r].Simulate(N);
QSN[r].Statistic(Ni);
}

​ <html><body>"
str << "
<< "​ <br>QSN Table"

23
 ​ <br>QS Number:"​ << qs
<< "
<< "​ <br>Sequence:"​;

​for​( i ​ nt​ i = ​1​; i < s; i++ ){

str << S[i​-1​] << ​"-"​ << S[i] << ​";"​;
}
str << ​"</table>"
​"<br><br><table border='1' cellpadding='0'
cellspacing='0'>"
​"<tr><td>QSN<td>l<td>m"​;
​for​( ​int​ q = ​0​; q < qs; q++ ){
str << ​"<tr><td>"​ << q;
​if​( q == ​0​) str << ​"<td>"​ << D[q];
​else​ str << ​"<td>-"​;
str << ​"<td>"​ << D[q+​1​];
}
str << ​"</table>"
<< ​"<br><br><table border='1' cellpadding='0'
cellspacing='0'>"
<< ​"<tr><td>r"​;
​for​( ​int​ q = ​0​; q < qs; q++ ){
str << ​"<td>QS"
<< ​"<td>T"
// << "<td>E[iat]"
// << "<td>E[st]"
<< ​"<td>E[nq]"
// << "<td>E[idt]"
<< ​"<td>E[w]"
// << "<td>E[s]"
// << "<td>E[r]"
// <<
"<td>V[iat]<td>V[st]<td>V[nq]<td>V[idt]<td>V[w]<td>V[s]<td>V[r]"
<< ​"<td>U"​;
// << "<td>p0";
}

​for​( i
​ nt​ r = ​0​; r < R; r++ ){
str << ​"<tr><td>"​ << r+​1​;
​for​( ​size_t​ qs = ​0​; qs < QSN[r].QS.size(); qs++ ){
str << ​"<td>"​ << qs
<< ​"<td>"​ << QSN[r].QS[qs].T

24
// << "<td>" << QSN[r].QS[qs].E[0] //
iat
// << "<td>" << QSN[r].QS[qs].E[1] //
st
<< ​"<td>"​ << QSN[r].QS[qs].E[​2​] ​//
nq
// << "<td>" << QSN[r].QS[qs].E[3] //
idt
<< ​"<td>"​ << QSN[r].QS[qs].E[​4​] ​// w
// << "<td>" << QSN[r].QS[qs].E[5] // s
// << "<td>" << QSN[r].QS[qs].E[6] // r
// << "<td>" << QSN[r].QS[qs].V[0]
// << "<td>" << QSN[r].QS[qs].V[1]
// << "<td>" << QSN[r].QS[qs].V[2]
// << "<td>" << QSN[r].QS[qs].V[3]
// << "<td>" << QSN[r].QS[qs].V[4]
// << "<td>" << QSN[r].QS[qs].V[5]
// << "<td>" << QSN[r].QS[qs].V[6]
<< ​"<td>"​ << QSN[r].QS[qs].U;
// << "<td>" << 1.0-QSN[r].QS[qs].U;
}
}
​return​ str.str();
}
int​ ​main​( ​void​ ){
​string​ str = RI();

ofstream fo;
fo.open(​"out.QSN.MM1-RI-C++.html"​);
replace(str.begin(), str.end(),​'.'​,​','​);
fo << str;
fo.close();

​return​ ​0​;
}
//----------------------------------------------------------------
--------------

Código Análise do Valor Médio

//

25
------------------------------------------------------------------
--
#​include​ ​<stdio.h>
#​include​ ​<stdlib.h>
#​include​ ​<fstream>
#​include​ ​<iostream>
#​include​ ​<iomanip>
#​include​ ​<cmath>
#​include​ ​<ctime>
#​include​ ​<vector>
#​include​ ​<string>
#​include​ ​<sstream>
#​include​ ​<algorithm>
//
------------------------------------------------------------------
--
using​ ​namespace​ ​std​;
//
------------------------------------------------------------------
--

int​ ​main​( ​void​ ){

​int​ N = ​15000​;
​double​ S0 = ​1.333333​, V0 = ​2​, D0 = S0*V0,
S1 = ​0.337837​, V1 = ​1​, D1 = S1*V1,
S2 = ​2 , V2 = ​2​, D2 = S2*V2,
S3 = ​0.181159​, V3 = 1​ ​, D3 = S3*V3,
S4 = ​7.5 , V4 = ​1​, D4 = S4*V4,

Q0, Q1, Q2, Q3, Q4,

R0, R1, R2, R3, R4,
U0, U1, U2, U3, U4,

R, X, Z = ​4.0​;

​stringstream​ ss;
ss << setprecision(​3​);

26
 ss << ​"n;R0;R1;R2;R3;R4;R;X;Q0;Q1;Q2;Q3;Q4;U0;U1;U2;U3;U4;"​ <<
endl​;

Q0 = Q1 = Q2 = Q3 = Q4 = ​0.0​; ​// n = 0;

​for​( i
​ nt​ n = ​1​; n <= N; n++ ){
R0 = S0*(​1.0​ + Q0);
R1 = S1*(​1.0​ + Q1);
R2 = S2*(​1.0​ + Q2);
R3 = S3*(​1.0​ + Q3);
R4 = S4*(​1.0​ + Q4);

R = R0*V0 + R1*V1 + R2*V2 + R3*V3 + R4*V4;

X = n/(R+Z);

Q0 = X*R0*V0;
Q1 = X*R1*V1;
Q2 = X*R2*V2;
Q3 = X*R3*V3;
Q4 = X*R4*V4;

U0 = Q0/(​1​+Q0);
U1 = Q1/(​1​+Q1);
U2 = Q2/(​1​+Q2);
U3 = Q3/(​1​+Q3);
U4 = Q4/(​1​+Q4);

ss << n << ​";"

​ ;"​ << R1 << ​";"​ << R2 << ​";"​ << R3 << ​";"​ <<
<< R0 << "
R4 << ​";"
<< R << ​";"​ << X << ​";"
​ ;"​ << Q1 << "
<< Q0 << " ​ ;"​ << Q2 << ​";"​ << Q3 << ​";"​ <<
Q4 << ​";"
<< U0 << ​";"​ << U1 << ​";"​ << U2 << ​";"​ << U3 << ​";"​ <<
U4 << ​endl​;
}

​string​ str = ss.str();

​cout​ << str;
ofstream fo;

27
 replace(str.begin(), str.end(),​'.'​,​','​);
fo.open(​"MVA-MS.csv"​);
fo << str;
fo.close();
​return​ ​0​;
}

28