SteadyStateEvolution.h

Go to the documentation of this file.

/*
Teem - an open source evolutionary software framework
http://lis.epfl.ch/resources/Teem
Stephane Magnenat <stephane.magnenat@epfl.ch>,
Antoine Beyeler <antoine.beyeler@epfl.ch>,
and other contributors.
Laboratory of Intelligent Systems, EPFL, Lausanne

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., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
*/

#ifndef STEADY_STATE_EVOLUTION_H
#define STEADY_STATE_EVOLUTION_H

#include "Evolution.h"
#include <set>
#include <ishtar/settings.h>

namespace Ishtar
{
    class InputStream;
    class OutputStream;
}

namespace Teem
{
    class Genome;
    
    class SteadyStateEvolutionRun;
    class Continuable;
    
    class SteadyStateIndividual
    {
    public:
        Genome *genome;
        double bornTime;
        double deathTime;
        unsigned childrenCount;
        Serializable *userData;
        
    public:
        SteadyStateIndividual(Genome *genome, double bornTime);
        SteadyStateIndividual(GenotypeDecoders &decoders, Continuable *experiment, Ishtar::InputStream *stream);
        ~SteadyStateIndividual();
        
        void load(GenotypeDecoders &decoders, Continuable *experiment, Ishtar::InputStream *stream);
        void save(Ishtar::OutputStream *stream);
    };
    
    typedef std::set<SteadyStateIndividual *> SteadyStatePopulation;
    
    class Continuable : public Setupable
    {
    public:
        virtual double step(SteadyStateEvolutionRun *evolution, double time) = 0;
        virtual Serializable *individualCreated(GenotypeDecoders &decoders, SteadyStateIndividual *self, SteadyStateIndividual *mother, SteadyStateIndividual *father) = 0;
    };
    
    class SteadyStateEvolutionRun : public EvolutionRun
    {
    protected:
        // inner class
        
        struct NewbornIndividuals
        {
            NewbornIndividuals(SteadyStateIndividual *self, SteadyStateIndividual *mother, SteadyStateIndividual *father) { this->self = self; this->mother = mother; this->father = father; }
            
            SteadyStateIndividual *self; 
            SteadyStateIndividual *mother; 
            SteadyStateIndividual *father; 
        };
        
        struct NewbornIndividualsCompareFunctor
        {
            bool operator()(const NewbornIndividuals &i1, const NewbornIndividuals &i2) const
            {
                return i1.self < i2.self;
            }
        };
        
        typedef std::set<NewbornIndividuals, NewbornIndividualsCompareFunctor> NewbornPopulation;
        
    protected:
        // members
        Ishtar::Variable<unsigned> initialPopulationSize;
        Ishtar::Variable<double> evolutionDuration;
        Ishtar::Variable<std::string> genotypeDecoderName;
        Ishtar::Variable<double> timeSaveInterval;
        
        NewbornPopulation toCreate;
        SteadyStatePopulation toKill;
        double time;
        double nextSaveTime;
        
    public:
        SteadyStatePopulation population;
    
    protected:
        // protected methods used internally
        virtual bool savePopulation(Setupable *experiment);
        virtual bool loadPopulation(Experiment *experiment, double timeToLoad);
        virtual bool loadPopulationFromStream(Experiment *experiment, Ishtar::InputStream *stream);
    
    public:
        // public methods from Evolution
        SteadyStateEvolutionRun();
        virtual ~SteadyStateEvolutionRun();
        
        virtual void createGenotypeDecoders(Setupable *experiment);
        
        virtual void createRandomPopulation();

        virtual bool loadPopulation(Experiment *experiment);
        virtual bool loadPopulation(Experiment *experiment, const char *timeToLoad) { return loadPopulation(experiment, atof(timeToLoad)); }
        
        virtual void run(Setupable *experiment);
            
        virtual void testBestIndividual(Setupable *experiment);
        virtual void testIndividual(Setupable *experiment, const char *);
        
    public:
        // public methods to be called from Continuable
        virtual void createRandomIndividual();
        virtual void createIndividual(SteadyStateIndividual *parent);
        virtual void createIndividual(SteadyStateIndividual *mother, SteadyStateIndividual *father);
        virtual void killIndividual(SteadyStateIndividual *individual);
    };
}

#endif

---