C:/dev/de/differentialevolution/selection_strategy.hpp

/*
 * Copyright (c) 2011 Adrian Michel
 * http://www.amichel.com
 *
 * Permission to use, copy, modify, distribute and sell this 
 * software and its documentation for any purpose is hereby 
 * granted without fee, provided that both the above copyright 
 * notice and this permission notice appear in all copies and in 
 * the supporting documentation. 
 *  
 * This library is distributed in the hope that it will be 
 * useful. However, Adrian Michel makes no representations about
 * the suitability of this software for any purpose.  It is 
 * provided "as is" without any express or implied warranty. 
 * 
 * Should you find this library useful, please email 
 * info@amichel.com with a link or other reference 
 * to your work. 
*/

#ifndef DE_SELECTION_STRATEGY_HPP_INCLUDED
#define DE_SELECTION_STRATEGY_HPP_INCLUDED

// MS compatible compilers support #pragma once

#if defined(_MSC_VER) && (_MSC_VER >= 1020)
#pragma once
#endif

#include "population.hpp"

namespace de
{

class selection_strategy
{
public:
        virtual ~selection_strategy(){}

        virtual void operator()( population_ptr& pop1, population_ptr& pop2, individual_ptr& bestInd, bool minimize ) = 0;
};

typedef boost::shared_ptr< selection_strategy > selection_strategy_ptr;

class best_parent_child_selection_strategy : public selection_strategy
{
public:
        void operator()( population_ptr& pop1, population_ptr& pop2, individual_ptr& bestInd, bool minimize )
        {
                assert( pop1 );
                assert( pop2 );

                assert( pop1->size() == pop2->size() );

                sort_across( *pop1, *pop2, minimize );

                // this is the best
                bestInd = (*pop1)[ 0 ];
        }

private:
        class individual_compare
        {
        private:
                const bool m_minimize;

        public:
                individual_compare( bool minimize )
                : m_minimize( minimize )
                {
                }

                bool operator()( individual_ptr ind1, individual_ptr ind2 )
                {
                        assert( ind1 && ind2 );

                        return ind1->better( ind2, m_minimize );
                }
        };

        void sort_across( population& v1, population& v2, bool minimize  )
        {
                v1.insert( v1.end(), v2.begin(), v2.end() );
                v2.clear();

                std::sort( v1.begin(), v1.end(), individual_compare( minimize ) );

                v2.insert( v2.end(), v1.begin() + v1.size() / 2, v1.end() );

                v1.erase( v1.begin() + v1.size()/2, v1.end() );
        }
};

class tournament_selection_strategy : public selection_strategy
{
public:
        void operator()( population_ptr& pop1, population_ptr& pop2, individual_ptr& bestInd, bool minimize )
        {
                assert( pop1 );
                assert( pop2 );

                assert( pop1->size() == pop2->size() );

                for( size_t i = 0; i < pop1->size(); ++i )
                {
                        individual_ptr crt( (*pop2)[ i ] );

                        if( crt->better_or_equal( (*pop1 )[ i ], minimize ) )
                        {
                                if( crt->better_or_equal( bestInd, minimize ) )
                                        bestInd = crt;
                        }
                        else
                                (*pop2)[ i ] = (*pop1)[ i ];

                }

                std::swap( pop1, pop2 );
        }
};

}

#endif //DE_SELECTION_STRATEGY_HPP_INCLUDED