Ir para o conteúdo
  • Revista PROGRAMAR: Já está disponível a edição #60 da revista programar. Faz já o download aqui!

Ana_80

Criar evento?

Mensagens Recomendadas

Ana_80

Tenho :

#include <assert.h>
#include <fstream>
#include "Simulador.h"
#include "Parametros.h"
#include "Aleatorios.h"
#include "Cliente.h"

Simulador::Simulador(void)
{
}


Simulador::~Simulador(void)
{
}

void Simulador::Inicializacao( int argc, char** argv )
{
std::ifstream stream( "Simulador.par", std::ios::in );
Parametros::Instance()->Ler( std::ifstream( "Simulador.par", std::ios::in ) );

// Geração do primeiro evento...
}

void Simulador::Execucao()
{
}

void Simulador::Finalizacao()
{
}

Tenho que gerar o primeiro evento que é a entrada no supermercado que é as 9h isto é para o código 9*60! para dar em minutos...nao estou a ver como gerar o evento...O cliente entra a partir da 9h e tenho que ver se o cliente pretende mais que 10unidades de compras e se é prioritáro ou não..

dps na classe simulador pediram para colocar void geraEventoChegada, void trataEventoChegada, void GeraFimServiço, void trataGeraFimServico, void geraAtendimento, void trata Atendimento e void gera FimAtendimento e finalmente void trata Fim Atenditmento..

Conclusão nao percebo o que é um Evento?? Tenho que criar alguma classe?? e isto do gera e trata...tentei ver alguns exmaplos nao nao vejo nada com isto...nem nos livros..

Alguem pode me ajudar?

Partilhar esta mensagem


Ligação para a mensagem
Partilhar noutros sites
Ana_80

estas a criar um simulador para verificação de calculo probabilístico ?

Sim, portanto é para identifica os clientes com numeros, e cada clientes na entrada vai ser determinado o nº de unidades k vai adquerir atraves do poisson e se o clientes é prioritario ou nao(1 em cada 30 clientes que entra é prioritario)...sendo prioritario pode ir para qualquer fila, tendo unidade<=10 vai para caixa 1.......não sei se estou a ser explicita

tenho:

#include <stdlib.h>
#include <math.h>
#include "alglib/specialfunctions.h" 
#include "Aleatorios.h"

void Aleatorios::Inicializacao( int argc, char* argv[] )
{
for ( int i = 1 ; i < argc ; i = i + 1 )
{
	if ( strcmp( "-semente", argv[i] ) != 0 ) continue;
	srand( atoi( argv[ i + 1 ] ) );
} 
}

int Aleatorios::ObsUnif( int n )
{
return int( ( double(rand()) / double(RAND_MAX) ) * double(n) );  
}

int Aleatorios::ObsUnif( int a, int b )
{
return ObsUnif( b - a + 1 ) + a;
}

int Aleatorios::ObsExp( int m )
{
return int( - double(m) * log( double(rand()) / double(RAND_MAX + 1) ) ); 
}

int Aleatorios::ObsPoisson( int m )
{
double probabilidade = double(rand()) / double(RAND_MAX);

for ( int x = 0 ; ; x++ )
{
	if ( probabilidade < alglib::poissondistribution( x, double(m) ) ) return x;
}
return 0;
}

e tenho

#include <iostream>
#include <fstream>
#include "Parametros.h"

// Não tentar preceber estas macros (muito complexo!!!)
#define OFFSET(membro) (int(&(((Parametros*)(NULL))->membro)))
#define MEMBRO(offset) (*(reinterpret_cast<int*>(reinterpret_cast<char*>(this)+offset)))

// Dimensão dos buffers
const int BUFFER_SIZE = 132;

struct Parametros::Parametro {
const char*  designacao;
const char*	 abreviatura;
int          offset;
};

Parametros::Parametro Parametros::mParametros[] = {
{ "Numero de Caixas",					"cxs",		OFFSET(mNumeroCaixas)        },
{ "Media entre chegada 1",				"mc1",		OFFSET(mMediaChegada[0])     },
{ "Media entre chegada 2",				"mc2",		OFFSET(mMediaChegada[1])     },
{ "Media de servico",					"ms",		OFFSET(mMediaServico)        },
{ "Media de atendimento 1",				"ma1",		OFFSET(mMediaAtendimento[0]) },
{ "Media de atendimento 2",				"ma2",		OFFSET(mMediaAtendimento[1]) },
{ "Media de atendimento 3",				"ma3",		OFFSET(mMediaAtendimento[2]) },
{ "Probabilidade de ser prioritario",	"pri",		OFFSET(mPrioritarios)	     }
};

int Parametros::mNumParametros = sizeof(mParametros) / sizeof(mParametros[0]);


Parametros::Parametros(void)
{
}


Parametros::~Parametros(void)
{
}

void Parametros::Ler( std::istream& stream )
{
static char buffer[bUFFER_SIZE];
while( ! stream.eof() )
{
  		stream.getline( buffer, BUFFER_SIZE, '\n' );

  		// Linhas em branco ou de comentário
  		if ( ( buffer[0] == '\0' ) || ( buffer[0] == '#' ) ) continue;

	const char* nome = LerNome( buffer );
	if ( nome == NULL ) continue;

	for ( int i = 0 ; i < mNumParametros ; i++ )
		if ( ( strcmp( nome, mParametros[i].designacao  ) == 0 ) ||
				( strcmp( nome, mParametros[i].abreviatura ) == 0 ) )
		{
				MEMBRO(mParametros[i].offset) = LerValor( buffer );
		}
}
}

void Parametros::Escrever( std::ostream& aStream )
{
aStream << "###############################################################################" << std::endl;
aStream << "#" << std::endl;
aStream << "# Parametros da simulacao" << std::endl;
aStream << "#" << std::endl;
aStream << std::endl;
aStream << "Numero de Caixas   = " << mNumeroCaixas << std::endl;
aStream << std::endl;
aStream << "# Medias" << std::endl;
aStream << std::endl;
aStream << "Media entre chegada 1  = " << mMediaChegada[0] << std::endl;
aStream << "Media entre chegada 2  = " << mMediaChegada[1] << std::endl;
aStream << "Media de servico       = " << mMediaServico  << std::endl;
aStream << "Media de atendimento 1 = " << mMediaAtendimento[0] << std::endl;
aStream << "Media de atendimento 2 = " << mMediaAtendimento[1] << std::endl;
aStream << "Media de atendimento 3 = " << mMediaAtendimento[2] << std::endl;
aStream << std::endl;
aStream << "# Probabilidades" << std::endl; 
aStream << std::endl;
aStream << "Probabilidade de ser prioritario = " << mPrioritarios << std::endl;
aStream << std::endl;
aStream << "###############################################################################" << std::endl;
aStream << std::endl;
}

const char* Parametros::LerNome( const char* aBuffer ) const
{
static char buffer[132];

const char* p = aBuffer;
while ( isspace( *p ) ) p++;

strcpy( buffer, p );

char* q = buffer;
while ( ( *q != '=' ) && ( *q != '\0' ) ) q++;
if ( *q == '\0' ) return NULL;

q--;
while ( isspace( *q ) ) q--;
*(q+1) = '\0';

return buffer;
}

int Parametros::LerValor( const char* aBuffer )
{
static char buffer[132];

const char* p = aBuffer;
while ( *p != '=' ) p++;
p++;
while ( isspace( *p ) ) p++;

strcpy( buffer, p );

char* q = buffer;
while ( isdigit( *q ) ) q++;
*q = '\0';

return atoi(buffer);
}

e tenho

#

# Parametros da simulacao

#

Numero de Caixas   =  10

# Medias

Media entre chegada 1  =  1

Media entre chegada 2  =  2

Media de servico      = 15

Media de atendimento 1 =  7

Media de atendimento 2 =  5

Media de atendimento 3 =  3

# Probabilidades

Probabilidade de ser prioritario = 30

#

Partilhar esta mensagem


Ligação para a mensagem
Partilhar noutros sites

Crie uma conta ou ligue-se para comentar

Só membros podem comentar

Criar nova conta

Registe para ter uma conta na nossa comunidade. É fácil!

Registar nova conta

Entra

Já tem conta? Inicie sessão aqui.

Entrar Agora

×

Aviso Sobre Cookies

Ao usar este site você aceita os nossos Termos de Uso e Política de Privacidade. Este site usa cookies para disponibilizar funcionalidades personalizadas. Para mais informações visite esta página.