C:/dev/de/differentialevolution/mutation_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_MUTATION_STRATEGY_HPP_INCLUDED
#define DE_MUTATION_STRATEGY_HPP_INCLUDED

// MS compatible compilers support #pragma once

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

#include "population.hpp"

#define URN_DEPTH 5

#include <boost/tuple/tuple.hpp>

namespace de
{

class mutation_strategy_arguments
{
private:
        const double m_weight;
        const double m_crossover;
        const double m_dither;

public:
        mutation_strategy_arguments( double weight, double crossover )
        : m_weight( weight ), m_crossover( crossover ), m_dither(  weight + genrand() * ( 1.0 - weight ) )
        {
                // todo: test or assert that weight and crossover are within bounds (0-1, 0-2 or something)
        }

        double weight() const { return m_weight; }
        double crossover() const { return m_crossover; }
        double dither() const { return m_dither; }
};

class mutation_strategy
{
private:
        mutation_strategy_arguments m_args;
        size_t m_varCount;

protected:
        class Urn
        {
                size_t m_urn[ URN_DEPTH ];

        public:
                Urn( size_t NP, size_t avoid )
                {
                        do m_urn[ 0 ] = genintrand( 0, NP, true ) ; while( m_urn[ 0 ] == avoid ) ;
                        do m_urn[ 1 ] = genintrand( 0, NP, true ) ; while( m_urn[ 1 ] == m_urn[ 0 ] || m_urn[ 1 ] == avoid );
                        do m_urn[ 2 ] = genintrand( 0, NP, true ) ; while( m_urn[ 2 ] == m_urn[ 1 ] || m_urn[ 2 ] == m_urn[ 0 ] || m_urn[ 2  ] == avoid );
                        do m_urn[ 3 ] = genintrand( 0, NP, true ) ; while( m_urn[ 3 ] == m_urn[ 2 ] || m_urn[ 3 ] == m_urn[ 1 ] || m_urn[ 3 ] == m_urn[ 0 ] || m_urn[ 3 ] == avoid );
                }

                size_t operator[]( size_t index ) const { assert( index < 4 ); return m_urn[ index ]; }
        };


public:
        virtual ~mutation_strategy()
        {
        }

        mutation_strategy( size_t varCount, const mutation_strategy_arguments& args )
        : m_args( args ), m_varCount( varCount )
        {
        }

        typedef boost::tuple< individual_ptr, de::DVectorPtr > mutation_info;

        virtual mutation_info operator()( const population& pop, individual_ptr bestIt, size_t i ) = 0;

        size_t varCount() const { return m_varCount; }

        double weight() const { return m_args.weight(); }

        double crossover() const { return m_args.crossover(); }

        double dither() const { return m_args.dither(); }
};

typedef boost::shared_ptr< mutation_strategy > mutation_strategy_ptr;

class mutation_strategy_1 : public mutation_strategy
{
public:
        mutation_strategy_1( size_t varCount, const mutation_strategy_arguments& args )
        : mutation_strategy( varCount, args )
        {
        }

        mutation_info operator()( const population& pop, individual_ptr bestIt, size_t i )
        {
                assert( bestIt );

                de::DVectorPtr origin( boost::make_shared< de::DVector >( varCount() ) );
                individual_ptr tmpInd( boost::make_shared< individual >( *pop[ i ]->vars() ) );
                Urn urn( pop.size(), i );
                

                // make sure j is within bounds
                size_t j = genintrand( 0, varCount(), true );
                size_t k = 0;

                do
                {
                        (*tmpInd->vars())[ j ] = (*pop[ urn[ 0 ] ]->vars() )[ j ] + weight() * ( (*pop[ urn[ 1 ] ]->vars() )[ j ] - (*pop[ urn[ 2 ] ]->vars())[ j ] );

                        j = ++j % varCount();
                        ++k;
                } while( genrand() < crossover() && k < varCount() );

                origin = pop[ urn[ 0 ] ]->vars();

                return mutation_info( tmpInd, origin );
        }

};

class mutation_strategy_2 : public mutation_strategy
{
public:
        mutation_strategy_2( size_t varCount, const mutation_strategy_arguments& args )
        : mutation_strategy( varCount, args )
        {
        }

        mutation_info operator()( const population& pop, individual_ptr bestIt, size_t i )
        {
                assert( bestIt );

                de::DVectorPtr origin( boost::make_shared< de::DVector >( varCount() ) );
                individual_ptr tmpInd( boost::make_shared< individual >( *pop[ i ]->vars() ) );
                Urn urn( pop.size(), i );
                

                // make sure j is within bounds
                size_t j = genintrand( 0, varCount(), true );
                size_t k = 0;

                do
                {
                        (*tmpInd->vars())[ j ] = (*tmpInd->vars())[ j ] + 
                                weight() * ( (*bestIt->vars() )[ j ] - (*tmpInd->vars())[ j ] ) +
                                weight() * ( (*pop[ urn[ 1 ] ]->vars() )[ j ] - (*pop[ urn[ 2 ] ]->vars())[ j ] );

                        j = ++j % varCount();
                        ++k;
                } while( genrand() < crossover() && k < varCount() );

                origin = pop[ urn[ 0 ] ]->vars();

                return mutation_info( tmpInd, origin );
        }

};

class mutation_strategy_3 : public mutation_strategy
{
public:
        mutation_strategy_3( size_t varCount, const mutation_strategy_arguments& args )
        : mutation_strategy( varCount, args )
        {
        }

        mutation_info operator()( const population& pop, individual_ptr bestIt, size_t i )
        {
                assert( bestIt );

                de::DVectorPtr origin( boost::make_shared< de::DVector >( varCount() ) );
                individual_ptr tmpInd( boost::make_shared< individual >( *pop[ i ]->vars() ) );
                Urn urn( pop.size(), i );
                

                // make sure j is within bounds
                size_t j = genintrand( 0, varCount(), true );
                size_t k = 0;

                do
                {
                        double jitter = (0.0001* genrand() + weight() );

                        (*tmpInd->vars())[ j ] = (*bestIt->vars() )[ j ] + jitter * ( (*pop[ urn[ 1 ] ]->vars() )[ j ] - (*pop[ urn[ 2 ] ]->vars())[ j ] );

                        j = ++j % varCount();
                        ++k;
                } while( genrand() < crossover() && k < varCount() );

                origin = pop[ urn[ 0 ] ]->vars();

                return mutation_info( tmpInd, origin );
        }
};

class mutation_strategy_4 : public mutation_strategy
{
public:
        mutation_strategy_4( size_t varCount, const mutation_strategy_arguments& args )
        : mutation_strategy( varCount, args )
        {
        }

        mutation_info operator()( const population& pop, individual_ptr bestIt, size_t i )
        {
                assert( bestIt );

                de::DVectorPtr origin( boost::make_shared< de::DVector >( varCount() ) );
                individual_ptr tmpInd( boost::make_shared< individual >( *pop[ i ]->vars() ) );
                Urn urn( pop.size(), i );
                

                // make sure j is within bounds
                size_t j = genintrand( 0, varCount(), true );
                size_t k = 0;

                double factor( weight() + genrand() * ( 1.0 - weight() ) );

                do
                {
                        double jitter = (0.0001* genrand() + weight() );

                        (*tmpInd->vars())[ j ] = (*pop[ urn[ 0 ] ]->vars() )[ j ] +
                                factor * ( (*pop[ urn[ 1 ] ]->vars() )[ j ] - (*pop[ urn[ 2 ] ]->vars())[ j ] );

                        j = ++j % varCount();
                        ++k;
                } while( genrand() < crossover() && k < varCount() );

                origin = pop[ urn[ 0 ] ]->vars();

                return mutation_info( tmpInd, origin );
        }

};



class mutation_strategy_5 : public mutation_strategy
{

public:
        mutation_strategy_5( size_t varCount, const mutation_strategy_arguments& args )
        : mutation_strategy( varCount, args )
        {
        }

        mutation_info operator()( const population& pop, individual_ptr bestIt, size_t i )
        {
                assert( bestIt );

                de::DVectorPtr origin( boost::make_shared< de::DVector >( varCount() ) );
                individual_ptr tmpInd( boost::make_shared< individual >( *pop[ i ]->vars() ) );
                Urn urn( pop.size(), i );

                // make sure j is within bounds
                size_t j = genintrand( 0, varCount(), true );
                size_t k = 0;

                do
                {
                        (*tmpInd->vars())[ j ] = (*pop[ urn[ 0 ] ]->vars() )[ j ] + dither() * ( (*pop[ urn[ 1 ] ]->vars() )[ j ] - (*pop[ urn[ 2 ] ]->vars() )[ j ] );

                        j = ++j % varCount();
                        ++k;
                } while( genrand() < crossover() && k < varCount() );

                origin = pop[ urn[ 0 ] ]->vars();
                return mutation_info( tmpInd, origin );
        }

};

}

#endif //DE_MUTATION_STRATEGY_HPP_INCLUDED