TProcuraMelhorativa.h

Go to the documentation of this file.

#pragma once
 
#include "../TProcura.h"
 
// um ponto no espaço de estados das soluções completas, é um apontador para um estado
class TProcuraMelhorativa;
typedef TProcuraMelhorativa* TPonto;
 
// nomes dos parâmetros fixos na procura melhorativa
enum EMelhorativas { movePrimeiroEM = parametrosProcura, populacaoAG,
    probMutacaoAG, distMinimaAG, parametrosMelhorativas
};
 
enum EIndicadoresConstrutiva {
    indEpocas = indProcura,    
    indGeracoes,               
    indMelhorativa             
};
 
 
//  TProcuraMelhorativa class
//  Author: José Coelho
//  Last revision: 2025-01-30
//  Description:
//    Superclasse de procuras no espaço das soluções completas (a solução é melhorada).
//    As variaveis da classe devem ser apenas de uma solucao, se existir informação
//    sobre a instancia, esta informação deve ser colocada em variaveis estáticas
//    para não serem duplicadas desnecessariamente.
//    A única variavel é o valor da solução que após ser calculada em Avaliar
//    deve ser actualizada (se o valor não estiver actualizado, deve ter -1)
class TProcuraMelhorativa :
    public TProcura
{
public:
    TProcuraMelhorativa(void);
    ~TProcuraMelhorativa(void);
 
    int custo; 
    int geracoes;
    int epocas;
 
    // Métodos para redefinir
 
    virtual TPonto Duplicar(void) = 0;
 
    virtual void Copiar(TPonto objecto) { }
 
    virtual void NovaSolucao(void);
    // Retorna o valor da solução completa actual. Atribuir o valor a custo
    virtual int Avaliar(void);
    // redefinir, para aceitar ações que sejam operadores
    bool Acao(const char* acao) { return false; }
    // Método para inicializar os parâmetros (redefinir se forem adicionados parâmetros específicos)
    void ResetParametros() override;
 
 
    // Operadores a redefinir para Escalada-do-Monte
 
    // Operador de vizinhanca (apenas em soluções completas)
    // chamar a função nesta classe para actualizacao de estatisticas
    virtual void Vizinhanca(TVector<TPonto>& vizinhos);
 
    // Algorithmos Evolutivos
 
    // Operador mutação, altera o estado actual (de acordo com a parametrizacao global)
    virtual void Mutar(void) { }
    // Operador cruzamento, cruza os dois elementos a e b, colocando o resultado no estado atual
    virtual void Cruzamento(TPonto a, TPonto b) { }
    // Função distância: distancia deste elemento ao elemento a
    // (opcional para manter os elementos diversos)
    virtual int Distancia(TPonto a) { return 0; }
 
    // Algoritmo de procura local: Escalada do Monte
    // retorna a avaliação do resultado actual
    int EscaladaDoMonte();
 
    // Algoritmo de procura local: Algoritmos Geneticos
    // retorna a avaliação do resultado final
    int AlgoritmoGenetico();
 
 
    // Método para teste manual do objecto (chamadas aos algoritmos, construcao de uma solucao manual)
    void TesteManualX(const char* nome); 
 
    // Chamar sempre que uma solução melhor que a actual e encontrada
    void DebugMelhorEncontrado(TPonto ponto);
 
    int Indicador(int id) override;
 
    void LimparEstatisticas(clock_t& inicio);
 
 
protected:
    // métodos internos
    void Selecao(int& pai, int& mae, TVector<int>& pesos, int total);
    void OrdemValor(TVector<TPonto>& populacao, TVector<int>& id);
    void CalcularAvaliacoes(TVector<TPonto>& vizinhos, int& melhorValor, int& melhorIndice);
    void VerificaMelhor(TPonto& melhor, TPonto atual);
    TPonto MelhorAtual(TPonto& atual, TVector<TPonto>& vizinhos, int indice);
    void ObterExtremos(TVector<TPonto>& populacao, int& minCusto, int& maxCusto);
    void Explorar() override;
    void LibertarVector(TVector<TPonto>& vector, int excepto = -1);
    int ExecutaAlgoritmo();
    // Mostrar vizinhos
    void DebugVizinhos(TVector<TPonto>& vizinhos);
    void DebugInicioEM(int ID, TPonto solucao);
    void DebugOptimoLocal(TPonto solucao);
    void DebugPassoEM(TPonto solucao);
    void DebugPassoAG(int pop, int min, int max);
    void DebugCruzamentoAG(int gPai, int gMae, int gFilho, int mutou);
};