TProcura.h

Go to the documentation of this file.

#pragma once
 
#define _CRT_SECURE_NO_WARNINGS
 
#include "TVector.h"
#include <time.h>
#include <stdint.h>
#include <limits.h>
#include <stdio.h>
 
 
// código para número não lido (não deve ser utilizado num parâmetro)
#define NAO_LIDO -1000000
 
 
enum EIndicadoresProcura {
    indResultado = 0, 
    indTempo,         
    indIteracoes,     
    indProcura        
};
 
enum EParametrosProcura {
    algoritmo = 0,         
    nivelDebug,            
    seed,                  
    limiteTempo,           
    limiteIteracoes,      
    parametrosProcura      
};
 
enum ENivelDebug {
    nada = 0,  
    atividade, 
    passos,    
    detalhe,   
    completo   
};
 
enum EOperacao { gravar = 0, ler };
 
 
// identificação de todos os indicadores definidos
typedef struct SIndicador {
    const char* nome;
    const char* descricao;
    int indice;
} TIndicador;
 
typedef struct SParametro {
    const char* nome;
    int valor;
    int min;
    int max;
    const char* descricao;
    const char** nomeValores;
} TParametro;
 
 
typedef struct SResultado {
    int instancia, configuracao;
    TVector<int> valor; // valor para cada indicador selecionado (fixos os EIndicadoresProcura, resultado, tempo, iterações)
} TResultado;
 
 
class TProcura
{
public:
    TProcura(void) {}
    virtual ~TProcura(void) {}
 
    virtual void Inicializar(void) { }
 
 
    virtual int ExecutaAlgoritmo() { return -1; }
 
    virtual int Indicador(int id);
 
    virtual void Debug(void);
 
    virtual void ResetParametros();
 
    virtual bool Parar(void) {
        return TempoExcedido() || IteracoesExcedido() || memoriaEsgotada;
    }
 
    virtual void TesteManual(const char* nome);
 
    virtual void TesteEmpirico(TVector<int> instancias, bool mostrarSolucoes = true, char* ficheiro = NULL);
 
    virtual void main(int argc, char* argv[], const char*nome);
 
    virtual void LimparEstatisticas(clock_t& inicio);
    virtual void ExecucaoTerminada(clock_t inicio);
    virtual void Explorar() {}
    virtual void MostrarSolucao();
    virtual TVector<int> CodificarSolucao() { return TVector<int>(); }
 
    static TParametro instancia;
    static char ficheiroInstancia[256];
    static TVector<TParametro> parametro;
    static TVector<TIndicador> indicador;
    static TVector<int> indAtivo; // lista por ordem dos indicadores a utilizar
    static TVector<TVector<int>> configuracoes;
    static int resultado;
    static int tempo;
    static int iteracoes;
    static clock_t instanteFinal;
    static bool memoriaEsgotada;
 
    bool TempoExcedido() { return instanteFinal < clock(); }
    bool IteracoesExcedido() {
        return Parametro(limiteIteracoes) > 0 && Parametro(limiteIteracoes) < iteracoes;
    }
    // ler um número, ou retorna NAO_LIDO
    static int NovoValor(const char* prompt);
    // ler uma string
    static char *NovoTexto(const char* prompt);
 
    // retorna o valor do parametro, para facilidade de uso
    int Parametro(int id) { return parametro[id].valor; }
 
protected:
 
    void InserirRegisto(TVector<TResultado>& resultados, int inst, int conf);
 
    int Registo(TResultado& resultado, int id);
 
    void Registo(TResultado& resultado, int id, int valor);
 
    void MostraParametros(int detalhe = 1, TVector<int>* idParametros = NULL);
 
    void MostraIndicadores();
 
    void MostrarConfiguracoes(int detalhe, int atual = -1);
 
    bool EditarIndicadores();
 
    void EditarParametros();
 
    void EditarConfiguracoes();
 
    void MostraRelatorio(TVector<TResultado>& resultados, bool ultimo = false);
 
    void ConfiguracaoAtual(TVector<int>& parametros, int operacao);
 
    int NovaConfiguracao(TVector<int>& parametros);
 
    int MelhorResultado(TResultado base, TResultado alternativa);
 
    void CalculaTorneio(TVector<TResultado>& resultados);
 
    void MostrarTorneio(TVector<TVector<int>>& torneio, bool jogo = false);
 
    void BarraTorneio(bool nomes);
 
    TVector<TResultado> ExtrairConfiguracao(TVector<TResultado>& resultados, int configuracao);
 
    void SolicitaInstancia();
 
    TVector<int> SolicitaInstancias();
 
    void RelatorioCSV(TVector<TResultado>& resultados, FILE* f);
 
    TVector<int> ExtraiLista(char* str);
 
    void InserirConfiguracoes(char* str, TVector<int>& base);
 
    void InserirConfiguracoes(TVector<int>& base, TVector<int>& produto, TVector<TVector<int>>& valores);
 
    void AjudaUtilizacao(const char* programa);
 
    static int Dominio(int& variavel, int min = INT_MIN, int max = INT_MAX);
};