C:/dev/de/differentialevolution/individual.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_INDIVIDUAL_HPP_INCLUDED
#define DE_INDIVIDUAL_HPP_INCLUDED

// MS compatible compilers support #pragma once

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

#include <queue>

#include "de_types.hpp"
#include "de_constraints.hpp"
#include "multithread.hpp"

namespace de
{

class individual;
typedef boost::shared_ptr< individual > individual_ptr;

class individual
{
private:
        de::DVectorPtr m_vars;
        double m_cost;
        de::mutex m_mx;

public:
        individual( size_t varCount )
        : m_vars( boost::make_shared< de::DVector >( varCount ) )
        {
        }

        individual( const de::DVector& vars )
                : m_vars( boost::make_shared< de::DVector >( vars ) )
        {
        }

        void init( constraints_ptr constraints )
        {
                assert( constraints );
                assert( m_vars );
                assert( m_vars->size() == constraints->size() );

                for( de::DVector::size_type j = 0; j < m_vars->size(); ++j ) 
                        (*m_vars)[ j ] = constraints->get_rand_value( j );
        }

        double cost() const { return m_cost; }

        void ensureConstraints( constraints_ptr constraints, de::DVectorPtr origin )
        {
                assert( constraints );
                assert( m_vars );
                assert( origin );
                assert( m_vars->size() == constraints->size() );

                for( de::DVector::size_type j = 0; j < m_vars->size(); ++j )
                {
                        (*m_vars)[ j ] = constraints->get_rand_value( j, (*m_vars)[ j ], (*origin)[ j ] );
                }
        }

        de::DVectorPtr vars() const { return m_vars; }

        de::Double& operator[]( size_t index ) { return (*m_vars)[ index ]; }

        const de::Double& operator[]( size_t index ) const { return (*m_vars)[ index ]; }

        void setCost( double cost ) { m_cost = cost; }

        bool operator<=( const individual& ind ) const
        {
                assert( ind.size() == size() );
                return cost() <= ind.cost();
        }

        bool operator<( const individual& ind ) const
        {
                assert( ind.size() == size() );
                return cost() < ind.cost();
        }

        bool better_or_equal( const individual_ptr ind, bool minimize ) const
        {
                assert( ind );
                return minimize ? *this <= *ind : *ind <= *this;
        }

        bool better( const individual_ptr ind, bool minimize ) const
        {
                assert( ind );
                return minimize ? *this < *ind : *ind < *this;
        }

        size_t size() const { return m_vars->size(); }

        std::string to_string() const
        {
                std::ostringstream os;

                os << "cost: " << cost() << ", vars: ";

                for( de::DVector::size_type j = 0; j < m_vars->size(); ++j )
                {
                        os << (*m_vars)[ j ] << ", ";
                }

                return os.str();

        }
};

typedef std::queue< individual_ptr > individual_queue_base;

class individual_queue : public individual_queue_base
{
private:
        de::mutex m_mx;

public:
        void push_back( individual_ptr ind )
        {
                de::lock lock( m_mx );

                individual_queue_base::push( ind );
        }

        individual_ptr pop()
        {
                de::lock lock( m_mx );

                if( !individual_queue_base::empty() )
                {
                        individual_ptr p( individual_queue_base::front() );

                        individual_queue_base::pop();

                        return p;
                }
                else
                        return individual_ptr();
        }
};

}

#endif //DE_INDIVIDUAL_HPP_INCLUDED