scaler.h

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

// Standard C Library
#include <cmath>

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

// libevocosm
#include "organism.h"

namespace libevocosm
{

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

        virtual ~scaler()
        {
            // nada
        }


        virtual void scale_fitness(vector<OrganismType> & a_population) = 0;
        

        void invert(vector<OrganismType> & a_population)
        {
            double base = min_element(a_population.begin(), a_population.end())->fitness()
                        + max_element(a_population.begin(), a_population.end())->fitness();
            
            for (typename vector<OrganismType>::iterator organism = a_population.begin(); organism != a_population.end(); ++organism)
               organism->fitness() = base - organism->fitness();
        }                
    };


    template <class OrganismType>
    class null_scaler : public scaler<OrganismType>
    {
    public:

        virtual void scale_fitness(vector<OrganismType> & a_population)
        {
            // nada
        }
    };


    template <class OrganismType>
    class linear_norm_scaler : public scaler<OrganismType>
    {
    public:

        linear_norm_scaler(double a_fitness_multiple = 2.0)
            : m_fitness_multiple(a_fitness_multiple)
        {
            // nada
        }


        virtual void scale_fitness(vector<OrganismType> & a_population)
        {
            // calculate max, average, and minimum fitness for the population
            double max_fitness = std::numeric_limits<double>::min();
            double min_fitness = std::numeric_limits<double>::max();
            double avg_fitness = 0.0;
            
            for (typename vector<OrganismType>::iterator org = a_population.begin(); org != a_population.end(); ++org)
            {
                // do we have a new maximum?
                if (org->fitness() > max_fitness)
                    max_fitness = org->fitness();
                
                // do we have a new minimum?
                if (org->fitness() < min_fitness)
                    min_fitness = org->fitness();
                
                // accumulate for average
                avg_fitness += org->fitness();
            }
            
            avg_fitness /= double(a_population.size());
            
            // calculate coefficients for fitness scaling
            double slope;
            double intercept;
            double delta;
            
            if (min_fitness > ((m_fitness_multiple * avg_fitness - max_fitness) / (m_fitness_multiple - 1.0)))
            {
                // normal scaling
                delta = max_fitness - avg_fitness;
                slope = (m_fitness_multiple - 1.0) * avg_fitness / delta;
                intercept = avg_fitness * (max_fitness - m_fitness_multiple * avg_fitness) / delta;
            }
            else
            {
                // extreme scaling
                delta = avg_fitness - min_fitness;
                slope = avg_fitness / delta;
                intercept = -min_fitness * avg_fitness / delta;
            }
            
            // adjust fitness values
            for (typename vector<OrganismType>::iterator org = a_population.begin(); org != a_population.end(); ++org)
                org->fitness() = slope * org->fitness() + intercept;
        }
        
    private:
        double m_fitness_multiple;
    };


    template <class OrganismType>
    class windowed_scaler : public scaler<OrganismType>
    {
    public:

        windowed_scaler()
        {
            // nada
        }


        virtual void scale_fitness(vector<OrganismType> & a_population)
        {
            // Find minimum fitness
            // Note that organisms sort in reverse order of fitness, such that
            // the "maximum" value has the smallest fitness.
            double min_fitness = min_element(a_population.begin(), a_population.end())->fitness();
            
            // assign new fitness values
            for (typename vector<OrganismType>::iterator org = a_population.begin(); org != a_population.end(); ++org)
                org->fitness() -= min_fitness;
        }
    };
    

    template <class OrganismType>
    class exponential_scaler : public scaler<OrganismType>
    {
    public:

        exponential_scaler(double a_a = 1.0, double a_b = 1.0, double a_power = 2.0)
          : m_a(a_a),
            m_b(a_b),
            m_power(a_power)
        {
            // nada
        }


        virtual void scale_fitness(vector<OrganismType> & a_population)
        {
            // assign new fitness values
            for (typename vector<OrganismType>::iterator org = a_population.begin(); org != a_population.end(); ++org)
                org->fitness() = pow((m_a * org->fitness() + m_b),m_power);
        }

    private:
        double m_a;
        double m_b;
        double m_power;
    };
    

    template <class OrganismType>
    class quadratic_scaler : public scaler<OrganismType>
    {
    public:

        quadratic_scaler(double a_a, double a_b, double a_c)
            : m_a(a_a), m_b(a_b), m_c(a_c)
        {
            // nada
        }


        virtual void scale_fitness(vector<OrganismType> & a_population)
        {
            // adjust fitness values
            for (typename vector<OrganismType>::iterator org = a_population.begin(); org != a_population.end(); ++org)
            {
                double f = org->fitness();
                org->fitness() = m_a * pow(f,2.0) + m_b * f + m_c;
            }
        }
        
    private:
        double m_a;
        double m_b;
        double m_c;
    };


    template <class OrganismType>
    class sigma_scaler : public scaler<OrganismType>
    {
    public:

        sigma_scaler()
        {
        }


        virtual void scale_fitness(vector<OrganismType> & a_population)
        {
            // calculate the mean
            double mean = 0.0;
            for (typename vector<OrganismType>::iterator org = a_population.begin(); org != a_population.end(); ++org)
                mean += org->fitness();
            
            mean /= static_cast<double>(a_population.size());
            
            // calculate variance
            double variance = 0.0;
            for (typename vector<OrganismType>::iterator org = a_population.begin(); org != a_population.end(); ++org)
            {
                double diff = org->fitness() - mean;
                variance += (diff * diff);
            }
            
            variance /= static_cast<double>(a_population.size() - 1);

            // calculate 2 times the std. deviation (sigma)
            double sigma2 = 2.0 * sqrt(variance);
            
            // now assign new fitness values
            if (sigma2 == 0.0)
            {
                for (typename vector<OrganismType>::iterator org = a_population.begin(); org != a_population.end(); ++org)
                    org->fitness() = 1.0;
            }
            else   
            {
                for (typename vector<OrganismType>::iterator org = a_population.begin(); org != a_population.end(); ++org)
                {
                    // change fitness
                    org->fitness() = (1.0 + org->fitness() / mean) / sigma2;
                    
                    // avoid tiny or zero fitness value; everyone gets to reproduce
                    if (org->fitness() < 0.1)
                        org->fitness() = 0.1;
                }
            }
        }
    };

};

#endif