Algorithm.h

#ifndef Algorithm_h
#define Algorithm_h
 
#include "State.h"
#include "SelectionOperator.h"
#include "Crossover.h"
#include "Mutation.h"
#include "EvaluateOp.h"
#include<vector>
 
class Algorithm
{
protected:
    DemeP activeDeme_;
    std::string name_;                               
    bool bImplicitParallel_;                         
    std::vector<SelectionOperatorP> selectionOp;     
 
    bool registerParameter(StateP state, std::string name, voidP value, enum ECF::type T, std::string description = "")
    {
        return state->getRegistry()->registerEntry(name_ + "." + name, value, T, description);
    }
 
    voidP getParameterValue(StateP state, std::string name)
    {
        return state->getRegistry()->getEntry(name_ + "." + name);
    }
 
#ifdef _MPI
    std::vector<IndividualP> requests_, stored_;           
    std::vector<uint> requestIds_;                         
    std::vector<IndividualP> demeCopy_;
    std::vector<IndividualP> myJob_;                       
    CommunicatorP comm_;
    uint jobSize_;
    uint totalEvaluations_, wastedEvaluations_;
    bool bImplicitEvaluation_;                             
    bool bImplicitMutation_;                               
    bool bSynchronized_;                                   
    SelectionOperatorP selBestOp;
    std::vector<IndividualP> requestsMut_, receivedMut_;   
    std::vector<uint> requestMutIds_;                      
    IndividualP currentBest_;
 
    std::vector<IndividualP> storedInds_;                  //<! last consistent version of an individual
    std::vector< std::vector<IndividualP> > sentInds_;     
    std::vector<bool> isConsistent_;                       
 
    void storeIndividual(IndividualP);                     
    void storeGenotypes(std::vector<IndividualP>&);        
    void setConsistency(IndividualP);                      
    void restoreIndividuals(std::vector<uint>);            
    void restorePopulation();                              
#endif
 
 
public:
    CrossoverP crossover_;                                 
    MutationP mutation_;                                   
    EvaluateOpP evalOp_;                                   
    StateP state_;
 
    Algorithm()
    {   bImplicitParallel_ = false; }
 
    virtual ~Algorithm()
    {   }
 
    std::string getName()
    {   return name_;   }
 
    virtual bool isParallel()
    {   return false;   }
 
    bool isImplicitParallel()
    {   return bImplicitParallel_;  }
 
    virtual bool advanceGeneration(StateP, DemeP) = 0;
 
    virtual bool initialize(StateP)
    {   return true;    }
 
    virtual void registerParameters(StateP) {}
 
    virtual bool initializePopulation(StateP);
 
    virtual void read() {}
 
#ifndef _MPI
 
    virtual bool advanceGeneration(StateP state)
    {
        ECF_LOG(state, 4, name_ + ": starting generation");
 
        bool bResult = true;
        for(uint iDeme = 0; iDeme < state->getPopulation()->size(); iDeme++) {
            activeDeme_ = state->getPopulation()->at(iDeme);
            bResult |= advanceGeneration(state, state->getPopulation()->at(iDeme));
        }
 
        ECF_LOG(state, 4, name_ + ": ending generation");
 
        return bResult;
    }
 
    void evaluate(IndividualP ind)
    {
        state_->getContext()->evaluatedIndividual = ind;
        ECF_LOG(state_, 5, "Evaluating individual: " + ind->toString());
        ind->fitness = evalOp_->evaluate(ind);
        ECF_LOG(state_, 5, "New fitness: " + ind->fitness->toString());
        state_->increaseEvaluations();
    }
 
    uint mutate(const std::vector<IndividualP>& pool)
    {   return mutation_->mutation(pool);   }
 
    uint mutate(const IndividualP victim)
    {   
        std::vector<IndividualP> pool;
        pool.push_back(victim);
        return mutation_->mutation(pool);
    }
 
    void replaceWith(IndividualP oldInd, IndividualP newInd)
    {   activeDeme_->replace(oldInd->index, newInd);    }
 
    void replaceWith(uint oldIndId, IndividualP newInd)
    {   activeDeme_->replace(oldIndId, newInd); }
 
    void registerParallelParameters(StateP state)
    {   }
 
    bool initializeParallel(StateP state)
    {   return true;    }
 
#else   // implicit parallel version
 
    virtual bool advanceGeneration(StateP state);
 
    virtual void bcastTermination(StateP state);
 
    void registerParallelParameters(StateP state);
 
    bool initializeParallel(StateP state);
 
    void initializeImplicit(StateP state);
 
    bool implicitParallelOperate(StateP state);
 
    void evaluate(IndividualP ind)
    {
        // implicit evaluation
        if(bImplicitEvaluation_)
            implicitEvaluate(ind);
        // if implicit mutation is active, check is evaluation needed
        else if(bImplicitMutation_ && ind->fitness->isValid())
            return;
        // else, evaluate the individual
        state_->getContext()->evaluatedIndividual = ind;
        ECF_LOG(state_, 5, "Evaluating individual: " + ind->toString());
        ind->fitness = evalOp_->evaluate(ind);
        ECF_LOG(state_, 5, "New fitness: " + ind->fitness->toString());
        state_->increaseEvaluations();
    }
 
    void implicitEvaluate(IndividualP ind);
 
    uint mutate(const IndividualP victim)
    {
        std::vector<IndividualP> pool;
        pool.push_back(victim);
        return mutate(pool);
    }
 
    uint mutate(const std::vector<IndividualP>& pool)
    {
        if(bImplicitMutation_) {
            uint nMutations = 0;
            for(uint i = 0; i < pool.size(); i++) {
                nMutations += implicitMutate(pool[i]);
            }
            return nMutations;
        }
        else
            return mutation_->mutation(pool);
    }
 
    uint implicitMutate(IndividualP ind);
 
    void replaceWith(IndividualP oldInd, IndividualP newInd);
 
    void replaceWith(uint oldIndId, IndividualP newInd)
    {   replaceWith(state_->getPopulation()->getLocalDeme()->at(oldIndId), newInd); }
 
#endif
 
// common functions (serial and parallel)
 
    bool mate(IndividualP p1, IndividualP p2, IndividualP child)
    {   return crossover_->mate(p1, p2, child); }
 
    IndividualP copy(IndividualP source)
    {   return (IndividualP) source->copy();    }
 
    bool removeFrom(IndividualP victim, std::vector<IndividualP> &pool)
    {
        uint iWorst = 0;
        while(iWorst < pool.size() && pool[iWorst] != victim)
            iWorst++;
        if(iWorst == pool.size())
            return false;
        pool.erase(pool.begin() + iWorst);
        return true;
    }
 
    bool isMember(IndividualP single, std::vector<IndividualP> &pool)
    {
        uint index = 0;
        while(index < pool.size() && pool[index] != single)
            index++;
        if(index == pool.size())
            return false;
        return true;
    }
};
typedef boost::shared_ptr<Algorithm> AlgorithmP;
 
#endif // Algorithm_h