D:/Projekt/ECF_trunk/ECF/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)
    {
        return state->getRegistry()->registerEntry(name_ + "." + name, value, T);
    }

    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_->getContext()->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 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
            ind->fitness = evalOp_->evaluate(ind);  
    }

    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);

#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