Sistemas de Telecomunicações I

Transcrição

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
• 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 B
13
28.9%
Origens
Central A
A
B
15
42.9%
C
28
59.6%
Central C
32
71.1%
20
19
57.1%
40.4%
Entrada e Saída
Entre A e B
Entrada em A ou B/Saída por C
Entrada em C/Saída em A ou B
Receita (UC por minuto)
1
3
5
Tabela 2 - Caracterização das chamadas
Duração média das chamadas dm = 2.5 minutos.
Central
A
B
C
Taxa de chegada λ = At/dm (erlang)
18
14
18.8
Tabela 3 - Taxas de chegada
Sistemas de Telecomunicações 1
45
35
47
Tabela 1- Caracterização do tráfego entre nós
Tipo de chamada
Local
Regional
25%
Nacional
75%
Totais
2
• 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 :
Rota BC :
Rota AC :
NAB=30
NBC=40
NAC=60
AAB=28.02
ABC=38.97
AAC=60.01
B ≈ 10 %
B ≈ 10%
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
:
Receita média/chamada
:
Duração da simulação
:
Duração média das chamadas :
Chamadas bloqueadas entre AB:
Chamadas bloqueadas entre AC:
Chamadas bloqueadas entre BC:
Total chamadas atendidas
:
Total chamadas bloqueadas
:
Total chamad reencaminhadas :
Total chamadas directas
:
Total de chamadas locais
:
Total de chamadas regionais :
Total de chamadas nacionais :
664877.688 U.C.
7.378 U.C.
1959.735 minutos
2.493 minutos
1960
4644
3283
90113
9887 - 9.887%
0
90113
22.2%
58.4%
19.4%
//chamadas
//chamadas
//chamadas
//chamadas
não bloqueadas
bloqueadas
encaminhadas dinamicamente
encaminhadas estaticamente
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 %
3
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.
7.408 U.C.
1961.796 minutos
2.496
2407
4296
3093
90204
9796 - 9.796%
642
89562
21.7%
59.0%
19.4%
Receita media
: 669304.88 U.C.
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
4
Rota AB
Rota BC
Rota AC
5
25.47
34.91
54.79
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
9760.08
10247.79
10738.14
11262.22
11774.22
12296.78
Receita Folga AB Folga BC
669304.9
0
9
667918.3
1
9
666463.1
2
9
665408.9
3
9
664043.4
4
9
662351.3
5
9
Tabela 7 – Folga AB variável
Folga AC
9
9
9
9
9
9
Bloqueio
9973.05
9902.94
9814.20
9806.91
9811.429
9760.08
9859.66
9864.32
9902.30
9831.38
9885.11
Receita
Folga AB Folga BC Folga AC
671388.3125
0
4
9
671117.6875
0
5
9
670289.9375
0
6
9
670038
0
7
9
669650.75
0
8
9
669304.875
0
9
9
668951
0
10
9
668513.75
0
11
9
668530.1875
0
12
9
668223.375
0
13
9
667943.8125
0
14
9
Tabela 8 – Folga BC variável
6
Bloqueio
9918.54
9909.3
9905.16
9881.65
9849.57
9760.08
9779.03
9805.77
9817.01
9893.97
9809.01
670600.6
0
9
670118.8
0
9
670029.9
0
9
669641.1
0
9
669690.8
0
9
669304.9
0
9
668933.5
0
9
668648.2
0
9
668585.3
0
9
668411.8
0
9
668399.2
0
9
Tabela 9 – Folga AC variável
7
Folga AC
4
5
6
7
8
9
10
11
12
13
14
8
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.
7.525 U.C.
1975.760 minutos
2.493
4005
3551
2381
90063
9937 - 9.937%
3269
86794
20.1%
59.9%
20.0%
Resultados finais das 100 execuções :
Receita media
: 673877.81 U.C.
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.
9
Gráfico 3 – Ocupação das rotas ao longo do tempo com encaminhamento dinâmico e optimização da receita
Rota AB
27.02
Rota BC
36.37
Rota AC
55.06
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
10482.87
11009.5
11503.08
12061.5
12561.59
13152.59
673877.8
0
2
672309.8
1
2
670888.6
2
2
669095.1
3
2
667613.9
4
2
665894.9
5
2
Tabela 12 – Folga A B variável
Folga AC
2
2
2
2
2
2
Bloqueio
10997.16
10803.12
10482.87
10364.55
10243.96
10198.62
10152.26
10139.24
10997.16
10803.12
10482.87
Receita
Folga AB Folga BC Folga AC
673262.4
0
0
2
673481.5
0
1
2
673877.8
0
2
2
673396.8
0
3
2
673256.1
0
4
2
672539.1
0
5
2
672299.6
0
6
2
671653.4
0
7
2
673262.4
0
0
2
673481.5
0
1
2
673877.8
0
2
2
Tabela 13 – Folga BC variável
10
Bloqueio
10942.43
10703.73
10482.88
10328.02
10280.61
10207.35
10180.2
10121.41
10942.43
10703.73
10482.88
Receita
672854.3
673422
673877.8
673767.1
673337.4
673635.1
673015.7
672402.9
672854.3
673422
673877.8
Folga AB
0
0
0
0
0
0
0
0
0
0
0
Folga BC
2
2
2
2
2
2
2
2
2
2
2
Tabela 14 – Folga AC variável
11
Folga AC
0
1
2
3
4
5
6
7
0
1
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 .
12
•
//
//
//
//
//
//
Código do programa
Simulacao de uma rede telefonica
By
Carlos Firmino
Ricardo Veloso
Rui Salgado
16 de Maio de 2000
#include
#include
#include
#include
#include
<stdlib.h>
<stdio.h>
<math.h>
<string.h>
<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
13
struct evento
{
tevento tipoev;
float tempo;
tcircuito circuito;
pevento next;
};
//tipo de evento
//tempo de ocorrência
//tipo de circuito
//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;
int bmfolg = 1;
int bestbloq =0;
int savecirc =0;
int comb = 0;
//
//
//
//
//
permite o reencaminhamento de chamadas
calcula as melhores folgas inicias
optimiza o bloqueio(1) ou a receita(0)
guarda a ocupação dos circuitos num ficheiro
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)
{
14
15
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
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");
}
no circuito
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;
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++)
16
{
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;
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;
ndir++;
ncham[r.cham]++;
}
inserir(inicio_A, nulo, randomt(ilambda_A));
inserir(inicio_B, nulo, randomt(ilambda_B));
inserir(inicio_C, nulo, randomt(ilambda_C));
// Primeiro evento de chegada de chamada em A
// Primeiro evento de chegada de chamada em B
// 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;
inserir(inicio_B, nulo, randomt(ilambda_B));
17
ntentadas++;
break;
case inicio_C:
if (RAND <= pC_A)
circ=AC;
else
circ=BC;
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)
{
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);
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);
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, AC, durac);
nreenc++;
ncham[r.cham]++;
}
else
{
nbloqBC++;
nbloq++;
}
}
if (circ==AC)
{
18
if ( (circuitos[AB] < (NMAX[AB]-folga[AB]) ) && (circuitos[BC] < (NMAX[BC]-folga[BC])) &&
(breenc==1))
{
inserir(fim, BC, durac);
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);
19
fprintf(stat,"Receita total
:
fprintf(stat,"Receita média/chamada
:
fprintf(stat,"Duração da simulação
:
fprintf(stat,"Duracão média das chamadas :
fprintf(stat,"Chamadas bloqueadas entre AB:
fprintf(stat,"Chamadas bloqueadas entre AC:
fprintf(stat,"Chamadas bloqueadas entre BC:
fprintf(stat,"Total chamadas atendidas
:
fprintf(stat,"Total chamadas bloqueadas
:
fprintf(stat,"Total chamad reencaminhadas :
fprintf(stat,"Total chamadas directas
:
fprintf(stat,"Total de chamadas locais
:
fprintf(stat,"Total de chamadas regionais :
fprintf(stat,"Total de chamadas nacionais :
%.3f U.C.\n", receita_total);
%.3f U.C.\n", M_receita);
%.3f minutos\n",t);
%.3f\n", M_duracao);
%d\n", nbloqAB);
%d\n", nbloqAC);
%d\n", nbloqBC);
%d\n",ntentadas-nbloq);
%d - %.3f%%\n",nbloq,(float)nbloq/chamadastotais*100);
%d\n",nreenc);
%d\n",ndir);
%.1f%%\n",(float)ncham[loc]/(ntentadas-nbloq)*100);
%.1f%%\n",(float)ncham[reg]/(ntentadas-nbloq)*100);
%.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");
20
//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)
{
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)
21
{
int folg[4], i = 0, dev=5;
int limInf,limSup;
FILE *texto;
struct retorno ret;
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");
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];
{
folga[BC]=i;
ret = executa(100);
}
fclose(texto);
//folga[AC] móvel
texto=fopen("AC.csv","w");
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];
{
folga[AC]=i;
ret = executa(100);
}
fclose(texto);
folga[AB] = folg[AB];
folga[BC] = folg[BC];
folga[AC] = folg[AC];
}
//*************************************************************************************************
22

Sistemas de Telecomunicações I

Transcrição

Documentos relacionados

Horário Escolar - 2014 - Colégio Estadual do Paraná

Road Map

HS35B

Indústrias fecham 4300 mil vagas de emprego na região

Grelha de jogos

Swifty

27 - CABO COAXIAL N46V3 TK

Kits ELECTROVISAO 200-9

8B. Redes PERT-CPM

7º ano