A Modelagem e Simulação

[pic 1]

Colegiado de Engenharia da Computação Universidade Federal do Vale do São Francisco

Modelagem e Simulação

Avaliação 6 :: 2020.1 :: 05/04/2021

Questão 1 (3 pontos): Qual a utilidade de Sxx?

Sxx é a variância do tempo de um pacote na fila. Serve para mostrar o quão longe o tempo que um pacote permanece na fila em relação a média dos pacotes que já passaram pelo servidor.

Questão 2 (3 pontos): Como eps é calculado?

Eps é calculado comparando o cpf do pacote atual com o sps do pacote anterior, se o cpf atual for maior que o sps do anterior então

Eps         recebe o cpf do pacote atual. Caso cpf atual seja menor que o sps do anterior então o eps do pacote atual recebe o sps do pacote anterior.

Questão 3 (4 pontos): Como ic é calculado?

Ic recebe o logaritmo negativo de um número aleatório (entre 0 e 1) e divide por lambda.

//---------------------------------------------------------------------

#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 );

    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( size_t p = 1; p < Pacote.size(); p++ ){

       size_t c = p-1;

       Pacote[p].nf = 0;

       while( Pacote[p].cpf < Pacote[c].sps ){

              Pacote[p].nf = Pacote[p].nf + 1;

              c--;

       }

  }

}

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 << "Simulacao de Sistema de Fila M/M/1 Metodo 1<hr>"

      << "Tabela<hr>"

      << "<table border='1'>"

      << "<tr><th>p<th>ic<th>cpf<th>eps<th>sps<th>nf";