sistemas de telecomunicações i -...

Sistemas de Telecomunicações I

Simulação de uma rede telefónica

Ricardo V. Oliveira

Carlos Firmino Rui Salgado

Maio, 2001

FEUP

ST1 - Simulação de uma rede com três centrais de comutação 1

Sistemas de Telecomunicações 1

• Rede a simular A topologia da rede que nos foi fornecida é a seguinte :

Figura 1 – tráfego oferecido aos nós (A) e capacidade das rotas de tráfego (N)

Destinos Central A Central B Central C

Totais

A 13 28.9% 32 71.1% 45

B 15 42.9% 20 57.1% 35

Orig

ens

C 28 59.6% 19 40.4% 47

Tabela 1- Caracterização do tráfego entre nós

Tipo de chamada Entrada e Saída Receita (UC por minuto) Local Entre A e B 1

Regional 25% Entrada em A ou B/Saída por C 3 Nacional 75% Entrada em C/Saída em A ou B 5

Tabela 2 - Caracterização das chamadas

Duração média das chamadas dm = 2.5 minutos.

Central Taxa de chegada λ = At/dm (erlang) A 18 B 14 C 18.8

Tabela 3 - Taxas de chegada



• Cálculo da probabilidade de bloqueio O cálculo da probabilidade de bloqueio fez-se aproximando o sistema por um sistema de Erlang. Para cada rota de tráfego λ i ≈ N × λ

onde i é o número de chamadas em curso na rota , N é a capacidade da rota e λ é a taxa de chegada de cada fonte livre à rota. Nesta situação λi é aproximadamente constante assim como o tráfego oferecido ao sistema em cada nó A ≈ N × λ× dm (onde dm é a duração média das chamadas) . Nesta situação , tanto A com λ i são independentes do número i de chamadas em curso. Para calcular o tráfego oferecido a cada rota teve de se ter em conta a caracterização do tráfego entre os nós terminais dessa rota . Para a rota A-B, temos a contribuição do nó A (45*0.289) mais a contribuição do nó B (35*0.429) (ver tabela 1). Sendo assim , o tráfego na rota A-B é de 28.02 Erlang. Consultando a tabela de tráfego conclui-se que, para esta rota , com NAB=30 e AAB=28.02 , a probabilidade de bloqueio é de 10%. Para os outros casos :

Rota AB : NAB=30 AAB=28.02 B ≈ 10 % Rota BC : NBC=40 ABC=38.97 B ≈ 10% Rota AC : NAC=60 AAC=60.01 B ≈ 10%

• Resultados da simulação :

O programa de simulação executa um número pré-determinado de vezes uma rotina que processa 100 mil chamadas com sementes sequenciais de geração de números aleatórios. No nosso caso, usaram -se 100 sementes , processando-se no total 100×100×103 =10 milhões de chamadas, para se obterem intervalos de confiança mais apertados. Os resultados obtidos foram escritos em ficheiros de texto para posterior análise.

o Resultados com encaminhamento estático :

Exemplo da execução n.º 100 :

****************** 100 ***************** Receita total : 664877.688 U.C. Receita média/chamada : 7.378 U.C. Duração da simulação : 1959.735 minutos Duração média das chamadas : 2.493 minutos Chamadas bloqueadas entre AB: 1960 Chamadas bloqueadas entre AC: 4644 Chamadas bloqueadas entre BC: 3283 Total chamadas atendidas : 90113 //chamadas não bloqueadas Total chamadas bloqueadas : 9887 - 9.887% //chamadas bloqueadas Total chamad reencaminhadas : 0 //chamadas encaminhadas dinamicamente Total chamadas directas : 90113 //chamadas encaminhadas estaticamente Total de chamadas locais : 22.2% Total de chamadas regionais : 58.4% Total de chamadas nacionais : 19.4%

Resultados finais das 100 execuções : ************ Resultados finais ***************** Receita media : 666276.50 U.C. Chamadas bloqueadas : 9885 - 9.885% Intervalo de confiança das receitas a 90% : +/- 343.3 U.C. Intervalo de confiança dos bloqueios a 90% : +/- 0.043 %



Verifica-se que a duração média das chamadas é aproximadamente 2.5 minutos. O intervalo de confiança dos bloqueios a +/– 90% é pequeno, permitindo percentagens de chamadas bloqueadas entre 9.842% e 9.928%.

Gráfico 1 – Ocupação das rotas ao longo do tempo com encaminhamento estático

Ocupação média dos circuitos N.º de circuitos ocupados Rota AB 25.08 Rota BC 34.86 Rota AC 54.08

Tabela 4 – Ocupação média das rotas com encaminhamento estático

o Resultados com encaminhamento dinâmico :

Para melhorar os resultados obtidos com o encaminhamento estático, optou-se por associar a cada rota uma folga. Para as chamadas locais, a folga é o número mínimo de circuitos livres que devem existir na rota AB para a chamada ser aceite. Isto só acontece para as chamadas locais porque são pouco frequentes e são as mais baratas, não sendo proveitoso fazer o seu encaminhamento pelos outros circuitos. Para as outras rotas, a chamada é aceite se existirem circuitos livres. Caso contrário, só são encaminhadas dinamicamente se as rotas alternativas tiverem um número de circuitos livres que é igual à folga nessa rota. Usou-se o mesmo algoritmo tanto no caso da optimização do bloqueio como no caso da receita. Esta optimização foi feita percorrendo todos as combinações possíveis das folgas.



o Optimização da percentagem de bloqueio : Os valores óptimos encontrados para as folgas foram de :

Rota Folga óptima AB 0 BC 9 AC 9

Tabela 5 – Folgas óptimas para o bloqueio Os resultados obtidos foram os seguintes : ****************** 100 ***************** Receita total : 668244.375 U.C. Receita média/chamada : 7.408 U.C. Duração da simulação : 1961.796 minutos Duração média das chamadas : 2.496 Chamadas bloqueadas entre AB: 2407 Chamadas bloqueadas entre AC: 4296 Chamadas bloqueadas entre BC: 3093 Total chamadas atendidas : 90204 Total chamadas bloqueadas : 9796 - 9.796% Total chamad reencaminhadas : 642 Total chamadas directas : 89562 Total de chamadas locais : 21.7% Total de chamadas regionais : 59.0% Total de chamadas nacionais : 19.4% ************ Resultados finais ***************** Receita media : 669304.88 U.C. Chamadas bloqueadas : 9760 - 9.760% Intervalo de confiança das receitas a 90% : +/- 329.8 U.C. Intervalo de confiança dos bloqueios a 90% : +/- 0.041 % Como se pode constatar, o encaminhamento dinâmico levou a que a probabilidade de bloqueio diminuísse para 9.76%. O intervalo de confiança manteve-se aproximadamente igual. Além de melhorar o bloqueio, a receita média por execução também aumentou .

Gráfico 2 – Ocupação das rotas ao longo do tempo com encaminhamento dinâmico e optimização do bloqueio



Tabela 6 – Ocupação média das rotas com encaminhamento dinâmico optimizando o bloqueio Verifica-se que a ocupação média dos circuitos não variou significativamente. Para ver como variam os resultados na vizinhança dos valores óptimos das folgas, testaram-se todas as combinações das folgas com duas delas fixas e variando a outra em torno do seu valor óptimo.

Bloqueio Receita Folga AB Folga BC Folga AC 9760.08 669304.9 0 9 9 10247.79 667918.3 1 9 9 10738.14 666463.1 2 9 9 11262.22 665408.9 3 9 9 11774.22 664043.4 4 9 9 12296.78 662351.3 5 9 9

Tabela 7 – Folga AB variável




Bloqueio Receita Folga AB Folga BC Folga AC 9973.05 671388.3125 0 4 9 9902.94 671117.6875 0 5 9 9814.20 670289.9375 0 6 9 9806.91 670038 0 7 9 9811.429 669650.75 0 8 9 9760.08 669304.875 0 9 9 9859.66 668951 0 10 9 9864.32 668513.75 0 11 9 9902.30 668530.1875 0 12 9 9831.38 668223.375 0 13 9 9885.11 667943.8125 0 14 9

Tabela 8 – Folga BC variável



Bloqueio Receita Folga AB Folga BC Folga AC 9918.54 670600.6 0 9 4 9909.3 670118.8 0 9 5

9905.16 670029.9 0 9 6 9881.65 669641.1 0 9 7 9849.57 669690.8 0 9 8 9760.08 669304.9 0 9 9 9779.03 668933.5 0 9 10 9805.77 668648.2 0 9 11 9817.01 668585.3 0 9 12 9893.97 668411.8 0 9 13 9809.01 668399.2 0 9 14

Tabela 9 – Folga AC variável



Os gráficos anteriores provam que as folgas anteriormente calculadas são óptimas. Também se observa que os resultados para a receita não são os melhores para as folgas óptimas do bloqueio, que demonstra que uma melhoria na probabilidade de bloqueio não significa uma melhoria na receita. Do gráfico da variação da folga AB vê-se que claramente que tanto para o bloqueio como para a receita, os melhores resultados ocorrem quando a folga é nula. Isto significa que a consideração inicial de reservar um determinado número de circuitos na rota AB para encaminhamento dinâmico não é vantajosa.

o Optimização da receita : Os valores óptimos encontrados para as folgas foram de :

Rota Folga óptima AB 0 BC 2 AC 2

Tabela 10 – Folgas óptimas para a receita Os resultados obtidos foram os seguintes : ****************** 100 ***************** Receita total : 677725.312 U.C. Receita média/chamada : 7.525 U.C. Duração da simulação : 1975.760 minutos Duração média das chamadas : 2.493 Chamadas bloqueadas entre AB: 4005 Chamadas bloqueadas entre AC: 3551 Chamadas bloqueadas entre BC: 2381 Total chamadas atendidas : 90063 Total chamadas bloqueadas : 9937 - 9.937% Total chamad reencaminhadas : 3269 Total chamadas directas : 86794 Total de chamadas locais : 20.1% Total de chamadas regionais : 59.9% Total de chamadas nacionais : 20.0%

Resultados finais das 100 execuções : ************ Resultados finais ***************** Receita media : 673877.81 U.C. Chamadas bloqueadas : 10483 - 10.483% Intervalo de confiança das receitas a 90% : +/- 268.7 U.C. Intervalo de confiança dos bloqueios a 90% : +/- 0.048 % Verifica-se que a receita média obtida é de 674 mil UC. Na situação com encaminhamento estático, a receita média era de 666 mil UC, enquanto que na situação de optimização do bloqueio a receita média foi de 669 mil UC. Constitui de facto uma melhoria da receita.



Gráfico 3 – Ocupação das rotas ao longo do tempo com encaminhamento dinâmico e optimização da receita


Tabela 11 – Ocupação média das rotas com encaminhamento dinâmico optimizando a receita Verifica-se que a ocupação média dos circuitos aumentou em relação ao encaminhamento dinâmico com optimização do bloqueio. Mantendo duas das folgas fixas e variando a outra em torno do seu valor óptimo, chegaram-se aos seguintes resultados :

Bloqueio Receita Folga AB Folga BC Folga AC 10482.87 673877.8 0 2 2 11009.5 672309.8 1 2 2 11503.08 670888.6 2 2 2 12061.5 669095.1 3 2 2 12561.59 667613.9 4 2 2 13152.59 665894.9 5 2 2

Tabela 12 – Folga AB variável



Bloqueio Receita Folga AB Folga BC Folga AC 10997.16 673262.4 0 0 2 10803.12 673481.5 0 1 2 10482.87 673877.8 0 2 2 10364.55 673396.8 0 3 2 10243.96 673256.1 0 4 2 10198.62 672539.1 0 5 2 10152.26 672299.6 0 6 2 10139.24 671653.4 0 7 2 10997.16 673262.4 0 0 2 10803.12 673481.5 0 1 2 10482.87 673877.8 0 2 2

Tabela 13 – Folga BC variável



Tabela 14 – Folga AC variável

Bloqueio Receita Folga AB Folga BC Folga AC 10942.43 672854.3 0 2 0 10703.73 673422 0 2 1 10482.88 673877.8 0 2 2 10328.02 673767.1 0 2 3 10280.61 673337.4 0 2 4 10207.35 673635.1 0 2 5 10180.2 673015.7 0 2 6 10121.41 672402.9 0 2 7 10942.43 672854.3 0 2 0 10703.73 673422 0 2 1 10482.88 673877.8 0 2 2



A observação dos gráficos anteriores comprova que as folgas calculadas são óptimas. Também se verifica que o valor das folgas em que a receita é máxima é diferente das folgas para a melhor probabilidade de bloqueio . Mais uma vez os gráficos provam que a optimização da receita é independente da optimização da percentagem de bloqueio .



• Código do programa

// Simulacao de uma rede telefonica // By // Carlos Firmino // Ricardo Veloso // Rui Salgado // 16 de Maio de 2000 #include <stdlib.h> #include <stdio.h> #include <math.h> #include <string.h> #include <time.h> // tempo médio entre chamadas consecutivas para cada central #define ilambda_A 1/18.0 #define ilambda_B 1/14.0 #define ilambda_C 1/18.8 #define dm 2.5 // Tráfego inicial entre nós #define A_B 13 #define A_C 32 #define B_A 15 #define B_C 20 #define C_A 28 #define C_B 19 // probabilidade de uma chamada ter origem em A e destino B #define pA_B 0.289 #define pB_A 0.429 #define pC_A 0.596 // probabilidade de uma chamada ser nacional ou regional #define pnacional 0.25 #define pregional 0.75 // custo de cada tipo de chamada por minuto #define clocal 1.0 #define cregional 3.0 #define cnacional 5.0 // número aleatório entre 0 e 1 #define RAND rand()/(float)RAND_MAX // número de chamadas totais da simulação por execução #define chamadastotais 100000 //número máximo de execuções #define NEXEC 100 //tipo de evento typedef enum {fim, inicio_A, inicio_B, inicio_C} tevento; //tipo de circuito typedef enum {nulo, AB, BC, AC} tcircuito; //tipo de chamada typedef enum {loc,reg,nac} tcham; //capacidade das rotas de tráfego const int NMAX [4] = {30, 30, 40, 60}; //apontador para um evento typedef struct evento *pevento; //estrutura de um evento



struct evento { tevento tipoev; //tipo de evento float tempo; //tempo de ocorrência tcircuito circuito; //tipo de circuito pevento next; //apontador para próximo evento }; //estrutura de retorno para a função 'executa' struct retorno { float rec,bloq; }; //estrutura de retorna para a função 'calcula_receita' struct ret_receita { float rec; tcham cham; }; //tempo da simulação float t = 0.0; //array com o nº de circuitos ocupados em cada ligação int circuitos[3]; //nº de chamadas bloqueadas e tentadas int nbloq = 0, ntentadas = 0; //apontador para o primeiro evento pevento first = NULL; //array com a duração e a receita de cada chamada float duracoes[chamadastotais], receita[chamadastotais]; //array com a receita e o nº de chamadas bloqueadas de cada execução float receitas[NEXEC], chamadas_bloq[NEXEC]; //média de receitas,média de chamadas bloqueadas, desvios padrões das receitas e chamadas bloqueadas float M_receita = 0, M_bloq = 0, S_rec=0, S_bloq=0; //nº de chamadas bloqueadas em cada circuito, indices diversos, nº de chamadas reencaminhadas e directas int nbloqAB = 0, nbloqAC = 0, nbloqBC = 0, pos_dur = 0, pos_rec = 0, nreenc=0, ndir=0; //array com as folgas de cada circuito int folga[4]; //array com o nº de chamadas de cada tipo (local,regional ou nacional) int ncham[3]; //tipo de simulaçao int breenc = 1; // permite o reencaminhamento de chamadas int bmfolg = 1; // calcula as melhores folgas inicias int bestbloq =0; // optimiza o bloqueio(1) ou a receita(0) int savecirc =0; // guarda a ocupação dos circuitos num ficheiro int comb = 0; // escreve ficheiro com todas as combinações das folgas //ficheiro de estatísticas FILE *stat; //ficheiro com a ocupação dos circuitos FILE *circtxt; //retorna um aleatório com a distribuição de Poisson com média 1/p float randomt(float p); //insere evento na lista de eventos void inserir(tevento ev, tcircuito circ, float t); //elimina o primeiro evento da lista void eliminar(); //inicializa o sistema void inicializacao(void); //corre a simulação void simulacao(void); //calcula a receita e o tipo de chamada struct ret_receita calcula_receita(tcircuito circ, float durac); int processa_chamada(tcircuito circ, float durac); //executa a simulação 'n' vezes struct retorno executa(int n); //algoritmo de optimização das folgas void melhores_folgas(void); void combinacoes(void); //************************************************************************************************* int main(void) {



stat=fopen("stats.txt","w"); if (bmfolg==1) { melhores_folgas(); } if ((bmfolg==0) && (breenc==1)) { printf("Inicializando as folgas\n"); folga[AB] = 0; folga[BC] = 5; folga[AC] = 1; //as folgas para o melhor bloqueio são 0-9-9 respectivamente //as folgas para a melhor receita são 0-2-2 respectivamente } fprintf(stat,"*********** Descrição da simulação **************\n\n"); if (breenc==1) { fprintf(stat,"-> Executa o encaminhamento dinâmico\n"); fprintf(stat,"-> Folgas utilizadas :\n no circuito AB=%d\n no circuito BC=%d\n no circuito AC=%d\n", folga[AB], folga[BC], folga[AC]); if (bestbloq==1) { fprintf(stat,"-> Optimiza o nº de chamadas bloqueadas\n"); } else { fprintf(stat,"-> Optimiza a receita $$\n"); } } else { fprintf(stat,"-> Executa o encaminhamento estático\n"); } if (savecirc==1) { circtxt=fopen("circs.csv","w"); fprintf(circtxt,"Tempo;Circuitos AB;Circuitos BC;Circuitos AC\n"); } if (comb==1) { combinacoes(); } executa(1); fclose(stat); if (savecirc==1) fclose(circtxt); return 1; } //************************************************************************************************* struct ret_receita calcula_receita(tcircuito c, float d) { struct ret_receita r; if (c == AB) { r.rec = (ceil(d*60)/60*clocal); //facturação ao segundo r.cham=loc; //a chamada é local } else { if ((c == AC) || (c == BC)) { if (RAND <= pnacional) { r.rec = (ceil(d*60)/60*cnacional); r.cham=nac; //a chamada é nacional }



else { r.rec = (ceil(d*60)/60*cregional); r.cham=reg; //a chamada é regional } } } return r; } //************************************************************************************************* void inserir(tevento ev, tcircuito circ, float tempo_ate_ocorrencia) { pevento ant = NULL, aux = first, nev; // Enquanto nao chegar ao evento imediatamente anterior passa para o seguinte while (aux != NULL) { if (aux->tempo > t + tempo_ate_ocorrencia) break; if ((aux->tempo == t + tempo_ate_ocorrencia) && (ev == fim)) break; ant = aux; aux = aux->next; } //Encontrou o local na lista para inserir o evento novo nev = (pevento) malloc (sizeof(struct evento)); nev -> tempo = t + tempo_ate_ocorrencia; nev -> tipoev = ev; nev -> circuito = circ; nev -> next = aux; if (ant == NULL) first = nev; else ant -> next = nev; if (ev == fim) //se for um evento de fim de chamada { duracoes[pos_dur++] = tempo_ate_ocorrencia; if (circ != nulo) circuitos[circ]++; } return; } //************************************************************************************************* void eliminar() { pevento aux; aux = first; first = first->next; free(aux); return; } //************************************************************************************************* float randomt(float p) { return -p*log(RAND); } //************************************************************************************************* void inicializacao(void) { int i; struct ret_receita r; float durac; ntentadas = A_B + B_A + A_C + C_A + B_C + C_B; //Chamadas entre A e B em ambos os sentidos for(i = 0; i < A_B+B_A; i++)



{ durac=randomt(dm); r=calcula_receita(AB, durac); inserir(fim, AB, durac); //receita+=r.rec; receita[pos_rec++]=r.rec; ndir++; ncham[r.cham]++; } //Chamadas entre A e C em ambos os sentidos for(i = 0; i < A_C+C_A; i++) { durac=randomt(dm); r=calcula_receita(AC, durac); inserir(fim, AC, durac); //receita+=r.rec; receita[pos_rec++]=r.rec; ndir++; ncham[r.cham]++; } //Chamadas entre B e C em ambos os sentidos for(i = 0; i < B_C+C_B; i++) { durac=randomt(dm); r=calcula_receita(BC, durac); inserir(fim, BC, durac); //receita+=r.rec; receita[pos_rec++]=r.rec; ndir++; ncham[r.cham]++; } inserir(inicio_A, nulo, randomt(ilambda_A)); // Primeiro evento de chegada de chamada em A inserir(inicio_B, nulo, randomt(ilambda_B)); // Primeiro evento de chegada de chamada em B inserir(inicio_C, nulo, randomt(ilambda_C)); // Primeiro evento de chegada de chamada em C if (savecirc==1) fprintf(circtxt,"%f;%d;%d;%d\n",t,circuitos[AB],circuitos[BC],circuitos[AC]); return; } //************************************************************************************************* void simulacao(void) { float duracao; tcircuito circ; t = first->tempo; duracao = randomt(dm); switch (first->tipoev) { case fim: //se for um evento de fim circuitos[first->circuito]--; //liberta o circuito ocupado break; case inicio_A: if (RAND <= pA_B) circ = AB; else circ = AC; processa_chamada(circ, duracao); inserir(inicio_A, nulo, randomt(ilambda_A)); ntentadas++; break; case inicio_B: if (RAND <= pB_A) circ = AB; else circ = BC; processa_chamada(circ, duracao); inserir(inicio_B, nulo, randomt(ilambda_B));



ntentadas++; break; case inicio_C: if (RAND <= pC_A) circ=AC; else circ=BC; processa_chamada(circ, duracao); inserir(inicio_C, nulo, randomt(ilambda_C)); ntentadas++; break; } eliminar(); if (savecirc==1) fprintf(circtxt,"%f;%d;%d;%d\n",t,circuitos[AB],circuitos[BC],circuitos[AC]); return; } //************************************************************************************************* int processa_chamada(tcircuito circ, float durac) { struct ret_receita r; r=calcula_receita(circ, durac); if (circ==AB) //é uma chamada local { //têm de ficar pelo menos 'folga[AB]' circuitos livres na ligação AB para a chamada ser aceite if (circuitos[AB] < (NMAX[AB]-folga[AB])) { inserir(fim, circ, durac); receita[pos_rec++]=r.rec; ndir++; ncham[r.cham]++; } else //se não é bloqueada { nbloqAB++; nbloq++; } } else //é uma chamada regional ou nacional { if (circuitos[circ] < NMAX[circ]) //se houver circuitos livres aceita a chamada com encaminhamento directo { inserir(fim, circ, durac); receita[pos_rec++]=r.rec; ndir++; ncham[r.cham]++; } else //se não tenta reencaminhar { if (circ==BC) { if ( (circuitos[AB] < (NMAX[AB]-folga[AB]) ) && (circuitos[AC] < (NMAX[AC]-folga[AC])) && (breenc==1)) { inserir(fim, AB, durac); inserir(fim, AC, durac); receita[pos_rec++]=r.rec; nreenc++; ncham[r.cham]++; } else { nbloqBC++; nbloq++; } } if (circ==AC) {



if ( (circuitos[AB] < (NMAX[AB]-folga[AB]) ) && (circuitos[BC] < (NMAX[BC]-folga[BC])) && (breenc==1)) { inserir(fim, AB, durac); inserir(fim, BC, durac); receita[pos_rec++]=r.rec; nreenc++; ncham[r.cham]++; } else { nbloqAC++; nbloq++; } } } } } //************************************************************************************************* struct retorno executa(int n) { int execs = 0, i; struct retorno ret; float receita_total, duracao_total, M_duracao, M_receita; while (execs < n) { t = 0; nbloq = 0; ntentadas = 0; nbloqAB = 0; nbloqAC = 0; nbloqBC = 0; pos_rec = 0; pos_dur = 0; M_duracao=0; M_receita=0; receita_total=0; duracao_total=0; nreenc=0; ndir=0; ncham[loc]=0; ncham[reg]=0; ncham[nac]=0; srand(execs+1); //srand(time(NULL)); inicializacao(); while (ntentadas < chamadastotais) { simulacao(); } //elimina a lista de eventos da memória while (first != NULL) { circuitos[first->circuito]--; eliminar(); } // Calculo da Media das durações e da receita de cada chamada for(i = 0; i <ntentadas-nbloq; i++) { duracao_total += duracoes[i]; receita_total += receita[i]; } M_duracao = duracao_total/(ntentadas-nbloq); M_receita = receita_total/(ntentadas-nbloq); if ((bmfolg!=1) && (comb==0)) { printf("Execução nº %d em %d - NBloq=%d - Preco=%f\n",execs+1,n,nbloq,receita_total); fprintf(stat,"\n****************** %d *****************\n\n",execs+1);



fprintf(stat,"Receita total : %.3f U.C.\n", receita_total); fprintf(stat,"Receita média/chamada : %.3f U.C.\n", M_receita); fprintf(stat,"Duração da simulação : %.3f minutos\n",t); fprintf(stat,"Duracão média das chamadas : %.3f\n", M_duracao); fprintf(stat,"Chamadas bloqueadas entre AB: %d\n", nbloqAB); fprintf(stat,"Chamadas bloqueadas entre AC: %d\n", nbloqAC); fprintf(stat,"Chamadas bloqueadas entre BC: %d\n", nbloqBC); fprintf(stat,"Total chamadas atendidas : %d\n",ntentadas-nbloq); fprintf(stat,"Total chamadas bloqueadas : %d - %.3f%%\n",nbloq,(float)nbloq/chamadastotais*100); fprintf(stat,"Total chamad reencaminhadas : %d\n",nreenc); fprintf(stat,"Total chamadas directas : %d\n",ndir); fprintf(stat,"Total de chamadas locais : %.1f%%\n",(float)ncham[loc]/(ntentadas-nbloq)*100); fprintf(stat,"Total de chamadas regionais : %.1f%%\n",(float)ncham[reg]/(ntentadas-nbloq)*100); fprintf(stat,"Total de chamadas nacionais : %.1f%%\n",(float)ncham[nac]/(ntentadas-nbloq)*100); } receitas[execs]=receita_total; chamadas_bloq[execs]=nbloq; execs++; } //Cálculo dos intervalos de confiança M_receita=0; M_bloq=0; for (i=0; i<n; i++) { M_receita+=receitas[i]; M_bloq+=chamadas_bloq[i]; } M_receita/=(float)n; M_bloq/=(float)n; for(i=0; i<n; i++) { S_rec += (receitas[i] - M_receita) * (receitas[i] - M_receita); S_bloq += (chamadas_bloq[i] - M_bloq) * (chamadas_bloq[i] - M_bloq); } S_bloq /= (n - 1); S_rec /= (n - 1); if ((bmfolg==0) && (comb==0)) { fprintf(stat,"\n************ Resultados finais *****************\n\n"); fprintf(stat,"Receita media : %.2f U.C.\n", M_receita); fprintf(stat,"Chamadas bloqueadas : %.0f - %.3f%%\n", M_bloq, M_bloq/chamadastotais*100); fprintf(stat,"Intervalo de confianca das receitas a 90%% : +/- %.1f U.C.\n", 1.65*sqrt(S_rec/n)); fprintf(stat,"Intervalo de confianca dos bloqueios a 90%% : +/- %.3f %%\n\n", 1.65*sqrt(S_bloq/n)/chamadastotais*100); printf("\n************ Resultados finais *****************\n\n"); printf("Receita media : %.2f U.C.\n", M_receita); printf("Chamadas bloqueadas : %.0f - %.3f%%\n", M_bloq, M_bloq/chamadastotais*100); printf("Intervalo de confianca das receitas a 90%% : +/- %.1f U.C.\n", 1.65*sqrt(S_rec/n)); printf("Intervalo de confianca dos bloqueios a 90%% : +/- %.3f %%\n\n", 1.65*sqrt(S_bloq/n)/chamadastotais*100); } ret.rec=M_receita; ret.bloq=M_bloq; return ret; } //************************************************************************************************* void melhores_folgas(void) { float nbloq_melhor = 0.0 , receita_melhor= 0.0 ; int folg[4], i = 0, j = 0, k = 0; FILE *texto; struct retorno ret; printf("Calculando as melhores folgas\n"); if (bestbloq) texto=fopen("BestBloq.txt","w"); else texto=fopen("BestPreco.txt","w");



//Optimização das folgas folga[AB] = 0; folga[BC] = 0; folga[AC] = 0; folg[AB] = 0; folg[BC] = 0; folg[AC] = 0; ret=executa(1); nbloq_melhor=ret.bloq; receita_melhor=ret.rec; for(k=0; k<NMAX[AC]/4; k++) { for(j=0; j<NMAX[BC]/4; j++) { for(i=0; i<1; i++) { folga[AB]=i; folga[BC]=j; folga[AC]=k; ret = executa(20); if (bestbloq==1) { if ( ret.bloq <= nbloq_melhor) { folg[AB] = folga[AB]; folg[BC] = folga[BC]; folg[AC] = folga[AC]; receita_melhor = ret.rec; nbloq_melhor = ret.bloq; printf("-> "); fprintf(texto,"-> "); } } else { if ( ret.rec >= receita_melhor) { folg[AB] = folga[AB]; folg[BC] = folga[BC]; folg[AC] = folga[AC]; receita_melhor = ret.rec; nbloq_melhor = ret.bloq; printf("-> "); fprintf(texto,"-> "); } } printf("Bloq=%f - Rec=%f - %d - %d - %d\n",ret.bloq,ret.rec,i,j,k); fprintf(texto,"Bloq=%f - Rec=%f - %d - %d - %d\n",ret.bloq,ret.rec,i,j,k); } } } fclose(texto); fprintf(stat,"Melhores folgas iniciais :\nfolga[AB]=%d\nfolga[BC]=%d\nfolga[AC]=%d\n",folg[AB],folg[BC],folg[AC]); fprintf(stat,"Melhor receita : %f\n",receita_melhor); fprintf(stat,"Melhor nº chamadas bloqueadas : %d\n",nbloq_melhor); printf("Melhores folgas iniciais :\nfolga[AB]=%d\nfolga[BC]=%d\nfolga[AC]=%d\n",folg[AB],folg[BC],folg[AC]); printf("Melhor receita : %f\n",receita_melhor); printf("Melhor nº chamadas bloqueadas : %f\n",nbloq_melhor); folga[AB] = folg[AB]; folga[BC] = folg[BC]; folga[AC] = folg[AC]; } //************************************************************************************************* void combinacoes(void)



{ int folg[4], i = 0, dev=5; int limInf,limSup; FILE *texto; struct retorno ret; folg[AB] = folga[AB]; folg[BC] = folga[BC]; folg[AC] = folga[AC]; printf("Calculando as melhores combinações das folgas\n"); //Optimização das folgas //folga[AB] móvel texto=fopen("AB.csv","w"); fprintf(texto,"Bloqueio;Receita;Folga AB;Folga BC;Folga AC\n"); folga[AB]=folg[AB]; folga[BC]=folg[BC]; folga[AC]=folg[AC]; limInf=(folg[AB]-dev); limSup=(folg[AB]+dev); if (limInf<0) limInf=0; if (limSup>NMAX[AB]) limSup=NMAX[AB]; for(i=limInf; i<=limSup; i++) { folga[AB]=i; ret = executa(100); printf("Bloq=%f - Rec=%f - %d - %d - %d\n",ret.bloq,ret.rec,folga[AB],folga[BC],folga[AC]); fprintf(texto,"%f;%f;%d;%d;%d\n",ret.bloq,ret.rec,folga[AB],folga[BC],folga[AC]); } fclose(texto); //folga[BC] móvel texto=fopen("BC.csv","w"); fprintf(texto,"Bloqueio;Receita;Folga AB;Folga BC;Folga AC\n"); folga[AB]=folg[AB]; folga[BC]=folg[BC]; folga[AC]=folg[AC]; limInf=(folg[BC]-dev); limSup=(folg[BC]+dev); if (limInf<0) limInf=0; if (limSup>NMAX[BC]) limSup=NMAX[BC]; for(i=limInf; i<=limSup; i++) { folga[BC]=i; ret = executa(100); printf("Bloq=%f - Rec=%f - %d - %d - %d\n",ret.bloq,ret.rec,folga[AB],folga[BC],folga[AC]); fprintf(texto,"%f;%f;%d;%d;%d\n",ret.bloq,ret.rec,folga[AB],folga[BC],folga[AC]); } fclose(texto); //folga[AC] móvel texto=fopen("AC.csv","w"); fprintf(texto,"Bloqueio;Receita;Folga AB;Folga BC;Folga AC\n"); folga[AB]=folg[AB]; folga[BC]=folg[BC]; folga[AC]=folg[AC]; limInf=(folg[AC]-dev); limSup=(folg[AC]+dev); if (limInf<0) limInf=0; if (limSup>NMAX[AC]) limSup=NMAX[AC]; for(i=limInf; i<=limSup; i++) { folga[AC]=i; ret = executa(100); printf("Bloq=%f - Rec=%f - %d - %d - %d\n",ret.bloq,ret.rec,folga[AB],folga[BC],folga[AC]); fprintf(texto,"%f;%f;%d;%d;%d\n",ret.bloq,ret.rec,folga[AB],folga[BC],folga[AC]); } fclose(texto); folga[AB] = folg[AB]; folga[BC] = folg[BC]; folga[AC] = folg[AC]; }

//*************************************************************************************************

sistemas de telecomunicações i -...

Documents