TProcura.h

Go to the documentation of this file.

#pragma once
 
#include "TVector.h"
#include <time.h>
#include <stdint.h>
#include <limits.h>
#include <stdio.h>
#include <inttypes.h> 
#include <cstdarg>
#include "compact.h"
 
 
// código para número não lido (não deve ser utilizado num parâmetro)
constexpr int NAO_LIDO = 1024;
 
// códigos de resultados inválidos, para o indicador de resultado (custo, qualidade, etc.)
constexpr int RES_IMPOSSIVEL = -1; // resultado impossível (prova de que não existe solução)
constexpr int RES_NAO_RESOLVIDO = -2; // resultado não resolvido (e.g. tempo esgotado, ou limite de iterações atingido)
constexpr int RES_INVALIDO = -3; // resultado do algoritmo inválido 
constexpr int RES_VAZIO = -4; // não existe resultado registado
 
// macros para ativar/desativar cinzento (ANSI)
#ifdef VPL_ATIVO
 
#define COR_LEVE " "
#define COR_RESET " "
#define COR_ATIVO " "
#define COR_INATIVO " "
#define COR_ATIVO_LEVE " "
#define COR_INATIVO_LEVE " "
 
#else
 
#define COR_LEVE "\x1b[90m"
#define COR_RESET "\x1b[0m"
#define COR_ATIVO "\x1b[92m"
#define COR_INATIVO "\x1b[91m"
#define COR_ATIVO_LEVE "\x1b[38;5;108m"
#define COR_INATIVO_LEVE "\x1b[38;5;131m"
 
#endif
constexpr int COR_LEVE_TAM = 9;   // bytes invisíveis (5 + 4), útil para alinhamento
 
enum EIndicadoresProcura {
    IND_RESULTADO = 0, 
    IND_TEMPO,         
    IND_ITERACOES,     
    IND_PROCURA        
};
 
enum EParametrosProcura {
    ALGORITMO = 0,        
    NIVEL_DEBUG,          
    SEMENTE,              
    LIMITE_TEMPO,         
    LIMITE_ITERACOES,     
    PARAMETROS_PROCURA    
};
 
enum ENivelDebug {
    NADA = 0,   
    ATIVIDADE,  
    PASSOS,     
    DETALHE,    
    COMPLETO,   
    EXTRA_DEBUG 
};
 
enum EOperacao { GRAVAR = 0, LER };
 
enum ECronometro {
    CONT_ALGORITMO = 0, 
    CONT_TESTE,         
    CONT_REPORTE,       
    CONT_PREPARACAO,    
    CONT_FINALIZACAO,   
    CONT_CHECKPOINT,    
    CONT_NUMERO         
};
 
enum ETagMPI {
    TAG_TRABALHO = 0,
    TAG_CABECALHO,
    TAG_VALORES,
    TAG_JOGO
};
 
enum class ECaixaParte {
    Topo,        // início da caixa
    Separador,   // linha de separação
    Meio,        // linha intermédia
    Fundo        // fecho da caixa
};
 
// identificação de todos os indicadores definidos
typedef struct SIndicador {
    TString nome;
    TString descricao = "";
    int indice = -1;
} TIndicador;
 
typedef struct SParametro {
    TString nome = "Indefinido";
    int valor = 0;
    int min = 0;
    int max = 0;
    TString descricao = "";
    TVector<TString> nomeValores;
    TVector<int> dependencia;
} TParametro;
 
 
typedef struct SResultado {
    int instancia = 0, configuracao = 0;
    TVector<int64_t> valor; // valor para cada indicador selecionado (fixos os EIndicadoresProcura, resultado, tempo, iterações)
    TVector<TString> solucao; // todas as ações da solução, se aplicável
} TResultado;
 
 
class TProcura
{
public:
    TProcura(void) {}
    virtual ~TProcura(void) {}
 
    virtual void Inicializar(void) { TRand::srand(Parametro(SEMENTE)); }
 
    // chamado se -FG definido, para gravar a instância
    virtual void Gravar(void) {}
 
 
    virtual int ExecutaAlgoritmo() { return -1; }
 
    virtual int64_t Indicador(int id);
 
    virtual void Debug(bool completo = true);
 
    virtual void ResetParametros();
 
    virtual bool Parar(void) {
        return TempoExcedido() || IteracoesExcedido() || memoriaEsgotada;
    }
 
    virtual void TesteManual(TString nome);
 
    virtual void TesteValidacao(TVector<int> instancias, TVector<int> impossiveis, TVector<int> referencias, TString fichSolucoes, TString fichResultados = "");
 
    virtual void RelatorioValidacao(TVector<TResultado> resultados, TVector<int> referencias);
 
    virtual bool Validar(TVector<TString> solucao) { return false; }
 
    virtual void TesteEmpirico(TVector<int> instancias, TString ficheiro = "");
 
    virtual void TesteEmpiricoGestor(TVector<int> instancias, TString ficheiro = "");
    virtual void TesteEmpiricoTrabalhador(TVector<int> instancias, TString ficheiro = "");
 
    virtual void main(int argc, char* argv[], TString nome);
 
    virtual void LimparEstatisticas();
    virtual void ExecucaoTerminada();
    virtual void Explorar() {}
    virtual void MostrarSolucao();
    virtual TVector<int64_t> CodificarSolucao() { return TVector<int64_t>(); }
    virtual TVector<TString> Solucao() { return {}; }
 
    static TParametro instancia;
    static TString ficheiroInstancia;
    static TString ficheiroGravar;
    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 double tempo;
    static int iteracoes;
    static clock_t instanteFinal;
    static bool memoriaEsgotada;
    static int mpiID;
    static int mpiCount;
    static int modoMPI;
    static int gravarSolucao;
    static int modoKMGT;
 
 
 
    bool TempoExcedido() { return instanteFinal < clock(); }
    bool IteracoesExcedido() {
        return Parametro(LIMITE_ITERACOES) > 0 && Parametro(LIMITE_ITERACOES) < iteracoes;
    }
    // ler um número, ou retorna NAO_LIDO
    static int NovoValor(TString prompt);
    // ler uma string
    static TString NovoTexto(TString prompt);
 
    // retorna o valor do parâmetro, para facilidade de uso (leitura e escrita)
    int Parametro(int id) const { return parametro[id].valor; }
    int& Parametro(int id) { return parametro[id].valor; }
    bool ParametroAtivo(int id, TVector<int>* valores = NULL) const {
        if (parametro[id].dependencia.Empty())
            return true;
        int valor;
        if (valores == NULL)
            valor = Parametro(parametro[id].dependencia.First());
        else
            valor = (*valores)[parametro[id].dependencia.First()];
        return parametro[id].dependencia.Find(valor, true, 1) >= 0;
    }
 
    static bool Debug(ENivelDebug tipo, bool exato, const char* fmt, ...) {
        int nivel = parametro[NIVEL_DEBUG].valor;
        if (exato ? nivel != tipo : nivel < tipo)
            return false;
        va_list args;
        va_start(args, fmt); // último parâmetro fixo é 'fmt'
        vprintf(fmt, args);
        va_end(args);
        return true;
    }
 
    static TString MostraTempo(double segundos);
    static TString MostraInt(int64_t valor, bool cor = true);
 
    static void MostraCaixa(TVector<TString> titulo, ECaixaParte parte, TVector<int> largura, bool aberta = true, int identacao = 0);
    static void MostraCaixa(TString titulo, ECaixaParte parte, int largura = 70, bool aberta = true, int identacao = 0, const char* icon = "");
    static void MostraCaixa(TVector<TString> textos, int largura = 70, bool aberta = true, int identacao = 0);
    static void Mensagem(TString titulo, const char* fmt, ...);
 
    static void MostraConjunto(TVector<int> valores, const char* etiqueta);
 
 
    static void DebugHSL(float h = -1, float s = 1.0, float l = 0.2, bool fundo = true);
 
protected:
 
    void ExecutaTarefa(TVector<TResultado>& resultados, int inst, int conf);
 
 
    void InserirRegisto(TVector<TResultado>& resultados, int inst, int conf);
 
    int64_t Registo(TResultado& resultado, int id);
 
    void Registo(TResultado& resultado, int id, int64_t valor);
 
    void MostraParametros(int detalhe = 1, TVector<int>* idParametros = NULL,
        TString titulo = "");
 
    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();
 
    bool RelatorioCSV(TVector<TResultado>& resultados, TString ficheiro, bool parametros = true);
 
    void InserirConfiguracoes(TString str, TVector<int>& base);
 
    void InserirConfiguracoes(TVector<int>& base, TVector<int>& produto, TVector<TVector<int>>& valores);
 
    void AjudaUtilizacao(TString programa);
 
    static int Dominio(int& variavel, int min = INT_MIN, int max = INT_MAX);
 
    static void InicializaMPI(int argc, char* argv[]);
    static void FinalizaMPI();
 
    void DebugTabela(ENivelDebug nivel, TVector<int>tabela, TString tipo = "",
            TString prefixo="", int modoCor=0, bool duplaColuna=false);
 
    bool JuntarCSV(TString ficheiro);
 
    static double Cronometro(enum ECronometro id = CONT_ALGORITMO, bool inicializar = false) {
        static clock_t inicio[CONT_NUMERO] = { 0 }; // até 10 cronómetros
        if (inicializar)
            inicio[id] = clock();
        return (double)(clock() - inicio[id]) / CLOCKS_PER_SEC;
    }
 
    void TesteInicio(TVector<int> &instancias, TVector<int> &configAtual);
    void TesteFim();
 
};
 
 
class TProcuraExecutavel : public TProcura
{
public:
 
    // variáveis necessárias redefinir após a construção
    TString solver; // caminho para o executável
    TParametro inst; // definição de instâncias existentes
    TVector<TIndicador> ind; // indicadores específicos, a calcular após a execução do executável, com base na saída do executável
    TVector<TString> indPrefixo = {"", "", ""}; // prefixo existente no output do programa, para cada indicador, de modo a extrair o valor do indicador
    // considerar também os indicadores em TProcura (IND_RESULTADO, IND_TEMPO, IND_ITERACOES), que podem ser extraídos do output do programa
    // string vazia para não extração desse indicador
    TVector<TParametro> par; // parâmetros específicos, para configurar a execução
    TVector<TString> parPrefixo = {"", "", "", "", ""}; // prefixo a dar nos argumentos do programa, para cada parâmetro, de modo a configurar a execução
    // considerar também os parâmetros em TProcura (ALGORITMO, NIVEL_DEBUG, SEMENTE, LIMITE_TEMPO, LIMITE_ITERACOES)
    // string vazia para não utilização desse parâmetro (se não há prefixo, apenas valor por ordem, utilizar um espaço)
    // Nota: o parâmetro é colocado nos argumentos do programa, apenas se não for igual ao valor por omissão
 
    // variáveis internas: 
    TVector<int64_t> indValores; // guarda os indicadores extraídos da última execução
    TVector<int> omissao; // valores de todos os parâmetros por omissão
 
    TProcuraExecutavel() : TProcura() {}
    ~TProcuraExecutavel(void) {}
 
    void ResetParametros();
 
    int ExecutaAlgoritmo();
 
    int64_t Indicador(int id);
 
    void Debug(bool completo) {}
};