selector.h

//---------------------------------------------------------------------
//  Algorithmic Conjurings @ http://www.coyotegulch.com
//  Evocosm -- An Object-Oriented Framework for Evolutionary Algorithms
//
//  selector.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(EVOCOSM_SELECTOR_H)
#define EVOCOSM_SELECTOR_H

// Standard C++ Library
#include <algorithm>

// libevocosm
#include "organism.h"

namespace libevocosm
{

    template <class OrganismType>
    class selector : protected globals
    {
    public:

        virtual ~selector()
        {
            // nada
        }


        virtual vector<OrganismType> select_survivors(vector<OrganismType> & a_population) = 0;
    };


    template <class OrganismType>
    class null_selector : public selector<OrganismType>
    {
    public:
        // Do-nothing selection function
        virtual vector<OrganismType> select_survivors(vector<OrganismType> & a_population)
        {
            return vector<OrganismType>(); // an empty vector
        }
    };


    template <class OrganismType>
    class elitism_selector : public selector<OrganismType>
    {
    public:

        elitism_selector(size_t a_how_many = 1)
            : m_how_many(a_how_many)
        {
            // nada
        }


        elitism_selector(const elitism_selector<OrganismType> & a_source)
            : m_how_many(a_source.how_many)
        {
            // nada
        }


        elitism_selector & operator = (const elitism_selector<OrganismType> & a_source)
        {
            m_how_many = a_source.m_how_many;
        }


        virtual vector<OrganismType> select_survivors(vector<OrganismType> & a_population);

    private:
        // number of organisms to keep
        size_t m_how_many;
    };

    template <class OrganismType>
    vector<OrganismType> elitism_selector<OrganismType>::select_survivors(vector<OrganismType> & a_population)
    {
        // create a new vector
        vector<OrganismType> chosen_ones;
            
        if (m_how_many > 0)
        {
            for (typename vector<OrganismType>::iterator i = a_population.begin(); i != a_population.end(); ++i)
            {
                typename vector<OrganismType>::iterator c = chosen_ones.begin();
                size_t n = 0;
                
                while ((c != chosen_ones.end()) && (n < m_how_many))
                {
                    if (i->fitness() > c->fitness())
                        break;
                        
                    ++c;
                    ++n;
                }
                
                if (n < m_how_many)
                    chosen_ones.insert(c,*i);
                
                if (chosen_ones.size() > m_how_many)
                    chosen_ones.pop_back();
            }
            
        }

        // return result
        return chosen_ones;
    }

};

#endif