evoga.h

/********************************************************************************
 *  FARSA Experiments Library                                                   *
 *  Copyright (C) 2007-2012                                                     *
 *  Stefano Nolfi <stefano.nolfi@istc.cnr.it>                                   *
 *  Onofrio Gigliotta <onofrio.gigliotta@istc.cnr.it>                           *
 *  Gianluca Massera <emmegian@yahoo.it>                                        *
 *  Tomassino Ferrauto <tomassino.ferrauto@istc.cnr.it>                         *
 *                                                                              *
 *  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 EVOGA_H
#define EVOGA_H
#include <cstdlib>
#include <stdio.h>
#include <string.h>
#include "evorobotexperiment.h"

#include <configurationparameters.h>
#include <parametersettable.h>

#include <QObject>
#include <QString>
#include <QMutex>
#include <QWaitCondition>

namespace farsa {

class FARSA_EXPERIMENTS_API Evoga : public QObject, public ParameterSettableWithConfigureFunction, public ConcurrentResourcesUser
{
    Q_OBJECT
signals:
    void startingReplication( int replication );
    void recoveredInterruptedEvolution( QString statfile );
    void endGeneration( int generation, double fmax, double faverage, double fmin );
    void finished();
public:
    static const int MAXINDIVIDUALS = 1000;
    Evoga();
    ~Evoga();

    void evolveSteadyState();
    void evolveGenerational();
    int mrand(int i);
    double drand();
    double getNoise(double minn, double maxn);  
    void  reproduce();
    void  mreproduce();
    void putGenome(int fromgenome, int tobestgenome);
    void getGenome(int frombestgenome, int togenome, int mut);  
    void setSeed(int s);
    int mutate(int w, double mut);
    void randomizePop();
    void setInitialPopulation(int*);
    void setMutations(float*);
    void printPop();
    void printBest();
    void saveagenotype(FILE *fp, int ind);
    void loadgenotype(FILE *fp, int ind);
    void saveallg();    
    int loadallg(int gen, const char *filew);
    void computeFStat();
    void computeFStat2();
    void saveFStat();
    void getLastFStat( double &min, double &max, double &average );
    int loadStatistics(char *filename);
    int* getGenes(int ind);
    int* getBestGenes(int ind);
    void resetGenerationCounter();
    void copyGenes(int from, int to, int mut);  
    void saveBestInd(); 
    void getPheParametersAndMutationsFromEvonet();

    void updateGenomeFromEvonet( int ind );

    virtual void configure(ConfigurationParameters& params, QString prefix);

    virtual void save(ConfigurationParameters& params, QString prefix);
    
    static void describe( QString type );
    
    virtual void postConfigureInitialization();

    virtual void evolveAllReplicas();
    
    void stop();
    
    bool commitStep();

    bool isStopped();
    
    void resetStop();
    
    bool isEnabledStepByStep();

    virtual EvoRobotExperiment* getEvoRobotExperiment();

    virtual QVector<EvoRobotExperiment*> getEvoRobotExperimentPool();

    virtual unsigned int currentGeneration();

    virtual unsigned int getStartingSeed();

    virtual unsigned int getCurrentSeed();

    virtual unsigned int getNumReplications();
    
    virtual unsigned int getNumOfGenerations();
    
    virtual double getCurrentMutationRate();

    virtual void setCurrentMutationRate( double mutation_rate );

    virtual unsigned int loadGenotypes(QString filename);

    virtual unsigned int numLoadedGenotypes() const;
    
    virtual int* getGenesForIndividual(unsigned int id);

    virtual QString statisticsFilename(unsigned int seed);

    virtual QString bestsFilename(unsigned int seed);

    virtual QString bestsFilename();

    virtual QString generationFilename(unsigned int generation, unsigned int seed);
    
    virtual QString generationFilename();
    
    virtual void doNotUseMultipleThreads();

public slots:
    void enableStepByStep( bool enable );
    void doNextStep();

private:
    EvoRobotExperiment *exp;
    int popSize;
    int glen;
    bool elitism;
    int nreproducing;
    int noffspring;

    class Population {
    public:
        Population() :
            m_pop(),
            m_genomelength(1)
        {
        }

        ~Population()
        {
            clear();
        }

        void setGenomeLength(int genomelength)
        {
            if (genomelength < 1) {
                genomelength = 1;
            }
            m_genomelength = genomelength;

            clear();
        }

        int getGenomeLength() const
        {
            return m_genomelength;
        }

        void resize(int newSize)
        {
            if (newSize < 0) {
                newSize = 0;
            }

            // We have to be careful clearing or allocating memory
            if (newSize < m_pop.size()) {
                for (int i = (m_pop.size() - 1); i >= newSize; i--) {
                    delete[] m_pop[i];
                }
                m_pop.resize(newSize);
            } else if (newSize > m_pop.size()) {
                const int oldSize = m_pop.size();
                m_pop.resize(newSize);
                for (int i = oldSize; i < newSize; i++) {
                    m_pop[i] = new int[m_genomelength];
                }
            }
        }

        int addOne()
        {
            m_pop.append(new int[m_genomelength]);

            // Returning the index of the new genome
            return (m_pop.size() - 1);
        }

        void clear()
        {
            resize(0);
        }

        int size() const
        {
            return m_pop.size();
        }

        int* operator[](int i)
        {
#ifdef FARSA_DEBUG
            if (i > m_pop.size()) {
                abort();
            }
#endif
            return m_pop[i];
        }

        const int* operator[](int i) const
        {
#ifdef FARSA_DEBUG
            if (i > m_pop.size()) {
                abort();
            }
#endif
            return m_pop[i];
        }

    private:
        QVector<int *> m_pop;
        int m_genomelength;
    };
    Population genome;
    Population bestgenome;
    int loadedIndividuals;
    double *tfitness;
    double *ntfitness;      
    double **statfit;
    QString evolutionType;
    int nogenerations;
    int nreplications;
    int seed;
    int currentSeed;
    double mutation;
    double mutationdecay;
    double initial_mutation;
    float *mutations;
    int cgen;
    int savebest;
    double fmin, fmax,faverage;
    int ccycle;
    bool stopEvolution;
    bool isStepByStep;
    QMutex mutexStepByStep;
    QWaitCondition waitForNextStep;
    unsigned int numThreads;
    int savePopulationEachNGenerations;
    bool averageIndividualFitnessOverGenerations;

    ConfigurationParameters savedConfigurationParameters;

    QString savedExperimentPrefix;
};

} // end namespace farsa

#endif