evocosm.h

//---------------------------------------------------------------------
//  Algorithmic Conjurings @ http://www.coyotegulch.com
//  Evocosm -- An Object-Oriented Framework for Evolutionary Algorithms
//
//  evocosm.h
//---------------------------------------------------------------------
//
//  Copyright 1996, 1999, 2002, 2003, 2004, 2005, 2007 Scott Robert Ladd
//
//  This program is free software; you can redistribute it and/or modify
//  it under the terms of the GNU General Public License as published by
//  the Free Software Foundation; either version 2 of the License, or
//  (at your option) any later version.
//  
//  This program is distributed in the hope that it will be useful,
//  but WITHOUT ANY WARRANTY; without even the implied warranty of
//  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
//  GNU General Public License for more details.
//  
//  You should have received a copy of the GNU General Public License
//  along with this program; if not, write to the
//      Free Software Foundation, Inc.
//      59 Temple Place - Suite 330
//      Boston, MA 02111-1307, USA.
//
//-----------------------------------------------------------------------
//
//  For more information on this software package, please visit
//  Scott's web site, Coyote Gulch Productions, at:
//
//      http://www.coyotegulch.com
//  
//-----------------------------------------------------------------------

#if !defined(LIBEVOCOSM_EVOCOSM_H)
#define LIBEVOCOSM_EVOCOSM_H

#if defined(_MSC_VER)
#pragma warning (disable : 4786)
#endif

#if defined(_OPENMP)
#include <omp.h>
#endif

// Standard C++ library
#include <vector>

// libevocosm
#include "validator.h"
#include "organism.h"
#include "landscape.h"
#include "mutator.h"
#include "reproducer.h"
#include "scaler.h"
#include "migrator.h"
#include "selector.h"
#include "reporter.h"


namespace libevocosm
{
    using std::vector;
    

    template <class OrganismType>
    class organism_factory
    {
    public:

        virtual OrganismType create() = 0;
    

        virtual void append(vector<OrganismType> & a_population, size_t a_size) = 0;
    };


    template <class LandscapeType>
    class landscape_factory
    {
    public:

        virtual LandscapeType generate() = 0;
    };


    template <class OrganismType, class LandscapeType>
    class evocosm : protected globals
    {
    protected:
        listener &                 m_listener;
            
        size_t                     m_population_size;

        vector< vector<OrganismType> > m_populations;

        size_t                     m_number_of_populations;

        size_t                     m_number_of_unique_landscapes;

        size_t                     m_number_of_common_landscapes;

        vector< vector<LandscapeType> > m_unique_landscapes;

        vector<LandscapeType>      m_common_landscapes;
        
        mutator<OrganismType>    & m_mutator;

        reproducer<OrganismType> & m_reproducer;

        scaler<OrganismType>     & m_scaler;

        migrator<OrganismType>   & m_migrator;

        selector<OrganismType>   & m_selector;

        reporter<OrganismType,LandscapeType> & m_reporter;
        
        size_t                     m_iteration;
        
        bool                       m_minimizing;
        
        bool                       m_running;

    public:

        evocosm(listener &                 a_listener,
                size_t                     a_population_size,
                size_t                     a_number_of_populations,
                size_t                     a_number_of_unique_landscapes,
                size_t                     a_number_of_common_landscapes,
                mutator<OrganismType>    & a_mutator,
                reproducer<OrganismType> & a_reproducer,
                scaler<OrganismType>     & a_scaler,
                migrator<OrganismType>   & a_migrator,
                selector<OrganismType>   & a_selector,
                reporter<OrganismType,LandscapeType> & a_reporter,
                organism_factory<OrganismType>   & a_organism_factory,
                landscape_factory<LandscapeType> & a_landscape_factory,
                bool                       a_minimizing = false);


        evocosm(const evocosm<OrganismType, LandscapeType> & a_source);


        virtual ~evocosm();


        evocosm & operator = (const evocosm<OrganismType, LandscapeType> & a_source);


        virtual bool run_generation(bool a_finished, double & a_fitness);


        vector<OrganismType, LandscapeType> & population(size_t a_index = 0)
        {
            return m_populations[a_index];
        }
        

        void terminate()
        {
            m_running = false;
        }
    };

    // constructors
    template <class OrganismType, class LandscapeType>
    evocosm<OrganismType, LandscapeType>::evocosm(listener &                 a_listener,
                                                  size_t                     a_population_size,
                                                  size_t                     a_number_of_populations,
                                                  size_t                     a_number_of_unique_landscapes,
                                                  size_t                     a_number_of_common_landscapes,
                                                  mutator<OrganismType>    & a_mutator,
                                                  reproducer<OrganismType> & a_reproducer,
                                                  scaler<OrganismType>     & a_scaler,
                                                  migrator<OrganismType>   & a_migrator,
                                                  selector<OrganismType>   & a_selector,
                                                  reporter<OrganismType, LandscapeType> & a_reporter,
                                                  organism_factory<OrganismType>   & a_organism_factory,
                                                  landscape_factory<LandscapeType> & a_landscape_factory,
                                                  bool                       a_minimizing)
      : m_listener(a_listener),
        m_population_size(a_population_size),
        m_populations(),
        m_number_of_populations(a_number_of_populations),
        m_number_of_unique_landscapes(a_number_of_unique_landscapes),
        m_number_of_common_landscapes(a_number_of_common_landscapes),
        m_unique_landscapes(),
        m_common_landscapes(),
        m_mutator(a_mutator),
        m_reproducer(a_reproducer),
        m_scaler(a_scaler),
        m_migrator(a_migrator),
        m_selector(a_selector),
        m_reporter(a_reporter),
        m_iteration(0),
        m_minimizing(a_minimizing),
        m_running(true)
    {
        // adjust evocosm size if necessary
        libevocosm::enforce_lower_limit(m_population_size,size_t(1));
        libevocosm::enforce_lower_limit(m_number_of_populations,size_t(1));

        // calculate number of common and unique landscapes
        if ((m_number_of_unique_landscapes < 1) && (m_number_of_common_landscapes == 0))
            m_number_of_unique_landscapes = 1;
        
        a_landscape_factory.generate();
        
        // allocate vectors of landscapes
        for (size_t n = 0; n < m_number_of_common_landscapes; ++n)
            m_common_landscapes.push_back(a_landscape_factory.generate());

        // create initial populations
        m_unique_landscapes.resize(m_number_of_populations);
        m_populations.resize(m_number_of_populations);
        
        for (size_t p = 0; p < m_number_of_populations; ++p)
        {
            // add organisms to populations
            a_organism_factory.append(m_populations[p], m_population_size);
            
            // create unique landscapes for this population
            for (size_t n = 0; n < m_number_of_unique_landscapes; ++n)
                m_unique_landscapes[p].push_back(a_landscape_factory.generate());
        }
    }

    // copy constructor
    template <class OrganismType, class LandscapeType>
    evocosm<OrganismType, LandscapeType>::evocosm(const evocosm<OrganismType, LandscapeType> & a_source)
      : m_population_size(a_source.m_population_size),
        m_populations(a_source.m_populations),
        m_number_of_populations(a_source.m_number_of_populations),
        m_number_of_common_landscapes(a_source.m_number_of_common_landscapes),
        m_number_of_unique_landscapes(a_source.m_number_of_unique_landscapes),
        m_common_landscapes(a_source.m_common_landscapes),
        m_unique_landscapes(a_source.m_unique_landscapes),
        m_mutator(a_source.m_mutator),
        m_reproducer(a_source.m_reproducer),
        m_scaler(a_source.m_scaler),
        m_migrator(a_source.m_migrator),
        m_selector(a_source.m_selector),
        m_iteration(a_source.m_iteration)
    {
        // nada
    }

    // destructor
    template <class OrganismType, class LandscapeType>
    evocosm<OrganismType, LandscapeType>::~evocosm()
    {
        // nada
    }

    // assignment operator
    template <class OrganismType, class LandscapeType>
    evocosm<OrganismType, LandscapeType> & evocosm<OrganismType, LandscapeType>::operator = (const evocosm<OrganismType, LandscapeType> & a_source)
    {
        m_population_size       = a_source.m_population_size;
        m_populations           = a_source.m_populations;
        m_number_of_populations = a_source.m_number_of_populations;

        m_number_of_common_landscapes = a_source.m_number_of_common_landscapes;
        m_number_of_unique_landscapes = a_source.m_number_of_unique_landscapes;
        m_common_landscapes           = a_source.m_common_landscapes;
        m_unique_landscapes           = a_source.m_unique_landscapes;
                
        m_mutator     = a_source.m_mutator;
        m_reproducer  = a_source.m_reproducer;
        m_scaler      = a_source.m_scaler;
        m_migrator    = a_source.m_migrator;
        m_selector    = a_source.m_selector;
        
        m_iteration   = a_source.m_iteration;

        return *this;
    }

    // compute next generation
    template <class OrganismType, class LandscapeType>
    bool evocosm<OrganismType, LandscapeType>::run_generation(bool a_finished, double & a_fitness)
    {
        int n, p;

        ++m_iteration;

        // announce beginning of new generation        
        m_listener.ping_generation_begin(m_iteration);
        
        // test fitness for each chromosome
        for (p = 0; p < (int)m_number_of_populations; p++)
        {
            // announce beginning of population processing
            m_listener.ping_population_begin(p + 1);
            
            // clear fitness
            // using an iterator here crashes MSVC++ 13.0 (.Net) with an internal error
            for (n = 0; n < (int)m_population_size; ++n) // vector<OrganismType>::iterator organism = m_populations[p].begin(); organism != m_populations[p].end; ++organism)
                m_populations[p][n].reset_all();
            
            // let other processes do something
            m_listener.yield();

            // accumulate fitness for each population common to all populations
            if (m_number_of_common_landscapes > 0)
            {
                for (n = 0; n < (int)m_number_of_common_landscapes; ++n)
                    m_common_landscapes[n].test_pop(m_populations[p]);
            }
            
            // let other processes do something
            m_listener.yield();

            // accumulate fitness for each landscape unique to this population
            if (m_number_of_unique_landscapes > 0)
            {
                for (n = 0; n < (int)m_number_of_unique_landscapes; ++n)
                    m_unique_landscapes[p][n].test_pop(m_populations[p]);
            }
            
            // announce completion of population processing
            m_listener.ping_population_end(p + 1);
        }

        // report on new generation
        bool keep_going = m_reporter.report(m_populations,m_iteration,a_fitness,a_finished);
        
        // let other processes do something
        m_listener.yield();
        
        if (keep_going && m_running)
        {
            // create next generation
            for (p = 0; p < (int)m_number_of_populations; ++p)
            {
                // reverse the sense of fitness when minimizing (i.e., best fitness is smallest value)
                if (m_minimizing)
                    m_scaler.invert(m_populations[p]);
                
                // let other processes do something
                m_listener.yield();

                // scale the population's fitness
                m_scaler.scale_fitness(m_populations[p]);
                
                // let other processes do something
                m_listener.yield();

                // get survivors and number of chromosomes to add
                vector<OrganismType> survivors = m_selector.select_survivors(m_populations[p]); 

                // let other processes do something
                m_listener.yield();

                // give birth to new chromosomes
                vector<OrganismType> children = m_reproducer.breed(m_populations[p], m_population_size - survivors.size());

                // let other processes do something
                m_listener.yield();

                // mutate the child chromosomes
                m_mutator.mutate(children);

                // let other processes do something
                m_listener.yield();

                // replace old evocosm with new one
                m_populations[p] = survivors;
                m_populations[p].insert(m_populations[p].end(),children.begin(),children.end());
            }

            if (m_number_of_populations > 1)
                m_migrator.migrate(m_populations);
        }

        // we're done with this generation        
        m_listener.ping_generation_end(m_iteration);
        
        // let other processes do something
        m_listener.yield();

        return keep_going & m_running;
    }
};

#endif