0

我正在使用名为ParadisEO的遗传算法库。我的算法运行良好,但我未能使用一个名为“档案”的库对象,该库对象在算法的整个生命周期内存储非支配个体(即最好的个体)。但是,当我尝试像在与库关联的所有示例中所做的那样声明存档对象时,我收到一条错误消息:“类型‘moeoUnboundedArchive’必须实现继承的纯虚方法‘moeoArchive::operator() '”。我不相信我已经覆盖了它!我在下面给出了我认为可能相关的代码子集,如果有帮助 的话,这里的库有很好的记录。

我会很感激你能给我的帮助!

我的代码是:

#include <stdio.h>
#include <stdlib.h>
#include <vector>
#include <eo>
#include <moeo>


class wetland_vector : public std::vector<int> {
    public:
    wetland_vector() : std::vector<int> (7,0) {}

};

std::istream& operator>>(std::istream& is, wetland_vector& q) {
    for (unsigned int i = 0; i < q.size(); ++i) {
        is >> q[i];
    }
    return is;
}

std::ostream& operator<<(std::ostream& os, const wetland_vector& q) {
    os << q[0];
    for (unsigned int i = 1; i < q.size(); ++i) {
        os << " " << q[i];
    }
    os << " ";
    return os;
}

class wetland_init : public eoInit<wetland_vector> {
    public:
    void operator()(wetland_vector& wetland_vector) {
        wetland_vector[0] = rng.random(10);
        wetland_vector[1] = rng.random(10);
        wetland_vector[2] = rng.random(100);
        wetland_vector[3] = rng.random(25);
        wetland_vector[4] = rng.random(100);
        wetland_vector[5] = rng.random(25);
        wetland_vector[6] = rng.random(25);
    }
};

class objective_vector_traits : public moeoObjectiveVectorTraits
{
public:
    static bool minimizing (int i)
    {
        return true;
    }
    static bool maximizing (int i)
    {
        return false;
    }
    static unsigned int nObjectives ()
    {
        return 2;
    }
};

typedef moeoRealObjectiveVector<objective_vector_traits> objective_vector;

class plan_vector : public moeoVector<objective_vector,wetland_vector,double,double>{
};

double dummy_evaluation_function_0(plan_vector& plan_vector){
    int sum = 0;
    for(unsigned int i = 0; i < plan_vector.size(); i++){
        for(unsigned int j = 0; j < plan_vector[i].size(); j++){
            sum += plan_vector[i][j];
        }
    }
    return sum;
}

double dummy_evaluation_function_1(plan_vector& plan_vector){
    int sum = 0;
    for(unsigned int i = 0; i < plan_vector.size(); i++){
        for(unsigned int j = 0; j < plan_vector[i].size(); j++){
            sum += plan_vector[i][j];
        }
    }
    return sum*sum;
}

class plan_vector_evaluation_object : public moeoEvalFunc <plan_vector>
{
    public:
    void operator () (plan_vector& plan_vector)
    {
        objective_vector objective_vector;
        objective_vector[0] = dummy_evaluation_function_0(plan_vector);
        objective_vector[1] = dummy_evaluation_function_1(plan_vector);
        plan_vector.objectiveVector(objective_vector);
    }
};

class eoMutate : public eoMonOp<plan_vector> {

        bool operator() (plan_vector& plan_vector) {

            int which_wet_vector = rng.random(plan_vector.size());
            int which_pos = rng.random(plan_vector[which_wet_vector].size());
            plan_vector[which_wet_vector][which_pos] = rng.random(10);

            return true;
        };
    };

    class eoQuadCross : public eoQuadOp<plan_vector> {

        public:

            bool operator() (plan_vector& vector_a, plan_vector& vector_b) {

                int a_size = vector_a.size();
                int b_size = vector_b.size();
                int min_chrom_length = 0;
                if(a_size <= b_size){
                    min_chrom_length = a_size;
                }
                if(b_size < a_size){
                    min_chrom_length = b_size;
                }

                unsigned int crossover_position = rng.random(min_chrom_length);
                for(unsigned int i = 0; i < crossover_position; i++){
                    std::vector<int> a_vec = vector_a[i];
                    std::vector<int> b_vec = vector_b[i];

                    vector_a[i].clear();
                    for(unsigned int j = 0; j < b_vec.size(); j++){
                        vector_a[i].push_back(b_vec[j]);
                    }
                    vector_b[i].clear();
                    for(unsigned int k = 0; k < a_vec.size(); k++){
                        vector_b[i].push_back(a_vec[k]);
                    }
                }

                return true;
            }

    };

    int main() {

int minimum_chromosome_length = 1;
int maximum_chromosome_length = 20;
int pop_size = 20;
int max_gen = 50;

//Prereq objects
wetland_init wetland_init;
eoInitVariableLength<plan_vector> plan_vector_init(minimum_chromosome_length, maximum_chromosome_length, wetland_init);
eoPop<plan_vector> pop(pop_size, plan_vector_init);
eoMutate mutate;
eoQuadCross crossover;
eoSGATransform<plan_vector> transform(crossover,0.75,mutate,0.05);
plan_vector_evaluation_object eval;
eoGenContinue<plan_vector> generation_count(max_gen);
eoCheckPoint<plan_vector> checkpoint(generation_count);

//THE PROBLEM IS HERE!!
moeoUnboundedArchive<plan_vector> archive;
moeoArchiveUpdater<plan_vector> updater(archive,pop);
checkpoint.add(updater);

//Set algorithm and go
moeoNSGAII<plan_vector> genetic_algorithm(checkpoint,eval,transform);
genetic_algorithm(pop);


for(unsigned int i = 0; i < archive.size(); i++){
    for(unsigned int j = 0; j < archive[i].size(); j++){
        for(unsigned int k = 0; k < archive[i][j].size(); k++){
            std::cout << archive[i][j][k] << " ";
        }
        std::cout <<  std::endl;
    }
}

return 0;
  }

moeoUnboundedArchive.h 是:

template < class MOEOT >
class moeoUnboundedArchive : public moeoArchive < MOEOT >
{
public:

/**
 * The type of an objective vector for a solution
 */
typedef typename MOEOT::ObjectiveVector ObjectiveVector;


/**
 * Default ctor.
 * The moeoObjectiveVectorComparator used to compare solutions is based on Pareto dominance
 * @param _replace boolean which determine if a solution with the same objectiveVector than another one, can replace it or not
 */
moeoUnboundedArchive(bool _replace=true) : moeoArchive < MOEOT >(_replace) {}


/**
 * Ctor
 * @param _comparator the moeoObjectiveVectorComparator used to compare solutions
 * @param _replace boolean which determine if a solution with the same objectiveVector than another one, can replace it or not
 */
moeoUnboundedArchive(moeoObjectiveVectorComparator < ObjectiveVector > & _comparator, bool _replace=true) : moeoArchive < MOEOT >(_comparator, _replace) {}


/**
 * Updates the archive with a given individual _moeo
 * @param _moeo the given individual
 * @return true if _moeo is added to the archive
 */
bool operator()(const MOEOT & _moeo)
{
    return this->update(_moeo);
}


/**
 * Updates the archive with a given population _pop
 * @param _pop the given population
 * @return true if a _pop[i] is added to the archive
 */
bool operator()(const eoPop < MOEOT > & _pop)
{
    return this->update(_pop);
}

};

最后,moeoArchive.h 是:

template < class MOEOT >
class moeoArchive : public eoPop < MOEOT >, public eoUF < const MOEOT &, bool>, public eoUF < const eoPop < MOEOT > &, bool>
 {
 public:

using eoPop < MOEOT > :: size;
using eoPop < MOEOT > :: operator[];
using eoPop < MOEOT > :: back;
using eoPop < MOEOT > :: pop_back;


/**
 * The type of an objective vector for a solution
 */
typedef typename MOEOT::ObjectiveVector ObjectiveVector;


/**
 * Default ctor.
 * The moeoObjectiveVectorComparator used to compare solutions is based on Pareto dominance
 * @param _replace boolean which determine if a solution with the same objectiveVector than another one, can replace it or not
 */
moeoArchive(bool _replace=true) : eoPop < MOEOT >(), comparator(paretoComparator), replace(_replace)
{}


/**
 * Ctor
 * @param _comparator the moeoObjectiveVectorComparator used to compare solutions
 * @param _replace boolean which determine if a solution with the same objectiveVector than another one, can replace it or not
 */
moeoArchive(moeoObjectiveVectorComparator < ObjectiveVector > & _comparator, bool _replace=true) : eoPop < MOEOT >(), comparator(_comparator), replace(_replace)
{}


/**
 * Returns true if the current archive dominates _objectiveVector according to the moeoObjectiveVectorComparator given in the constructor
 * @param _objectiveVector the objective vector to compare with the current archive
 */
bool dominates (const ObjectiveVector & _objectiveVector) const
{
    for (unsigned int i = 0; i<size(); i++)
    {
        // if _objectiveVector is dominated by the ith individual of the archive...
        if ( comparator(_objectiveVector, operator[](i).objectiveVector()) )
        {
            return true;
        }
    }
    return false;
}


/**
 * Returns true if the current archive already contains a solution with the same objective values than _objectiveVector
 * @param _objectiveVector the objective vector to compare with the current archive
 */
bool contains (const ObjectiveVector & _objectiveVector) const
{
    for (unsigned int i = 0; i<size(); i++)
    {
        if (operator[](i).objectiveVector() == _objectiveVector)
        {
            return true;
        }
    }
    return false;
}




/**
 * Updates the archive with a given individual _moeo
 * @param _moeo the given individual
 * @return if the _moeo is added to the archive
 */
virtual bool operator()(const MOEOT & _moeo) = 0;


/**
 * Updates the archive with a given population _pop
 * @param _pop the given population
 * @return if at least one _pop[i] is added to the archive
 */
virtual bool operator()(const eoPop < MOEOT > & _pop) = 0;


/**
 * Returns true if the current archive contains the same objective vectors than the given archive _arch
 * @param _arch the given archive
 */
bool equals (const moeoArchive < MOEOT > & _arch)
{
    for (unsigned int i=0; i<size(); i++)
    {
        if (! _arch.contains(operator[](i).objectiveVector()))
        {
            return false;
        }
    }
    for (unsigned int i=0; i<_arch.size() ; i++)
    {
        if (! contains(_arch[i].objectiveVector()))
        {
            return false;
        }
    }
    return true;
}

protected:
/**
 * Updates the archive with a given individual _moeo
 * @param _moeo the given individual
 */
bool update(const MOEOT & _moeo)
{
    // first step: removing the dominated solutions from the archive
    for (unsigned int j=0; j<size();)
    {
        // if the jth solution contained in the archive is dominated by _moeo
        if ( comparator(operator[](j).objectiveVector(), _moeo.objectiveVector()) )
        {
            operator[](j) = back();
            pop_back();
        }
        else if (replace && (_moeo.objectiveVector() == operator[](j).objectiveVector()))
        {
            operator[](j) = back();
            pop_back();
        }
        else
        {
            j++;
        }
    }
    // second step: is _moeo dominated?
    bool dom = false;
    for (unsigned int j=0; j<size(); j++)
    {
        // if _moeo is dominated by the jth solution contained in the archive
        if ( comparator(_moeo.objectiveVector(), operator[](j).objectiveVector()) )
        {
            dom = true;
            break;
        }
        else if (!replace && (_moeo.objectiveVector() == operator[](j).objectiveVector()) )
        {
            dom = true;
            break;
        }
    }
    if (!dom)
    {
        this->push_back(_moeo);
    }
    return !dom;
}


/**
 * Updates the archive with a given population _pop
 * @param _pop the given population
 */
bool update(const eoPop < MOEOT > & _pop)
{
    bool res = false;
    bool tmp = false;
    for (unsigned int i=0; i<_pop.size(); i++)
    {
        tmp = (*this).update(_pop[i]);
        res = tmp || res;
    }
    return res;
}

/** The moeoObjectiveVectorComparator used to compare solutions */
moeoObjectiveVectorComparator < ObjectiveVector > & comparator;
/** A moeoObjectiveVectorComparator based on Pareto dominance (used as default) */
moeoParetoObjectiveVectorComparator < ObjectiveVector > paretoComparator;
/** boolean */
bool replace;
};
4

0 回答 0