evolib.h

Idź do dokumentacji tego pliku.

#ifndef EVOPOPULATION_H
#define EVOPOPULATION_H

#include<iostream>
#include<fstream>
#include<sstream>
#include<cstdlib>
#include<ctime>
#include<cstddef>
#include<string>
#include<vector>
#include<list>
#include<iterator>
#include<math.h>
#include<fcntl.h>

using namespace std;

template<class T>
class EvoRandomizer;

class EvoTest
{
        public:
        EvoTest(){}
        EvoTest(int i,char*f,int d) : size(i), filename(f), id(d){}
        virtual ~EvoTest(){}
        virtual double run(double* ix,int a) = 0;
        char* filename;
        int size;
        int id;
};

class Test6 : public EvoTest
{
        public:
                Test6(int i,char*f,int d) : EvoTest(i,f,d){}
                double run(double* x,int n){
                        return (-1)*(100*pow((x[1]-x[0]*x[0]),2) + pow((1 - x[0]),2) + 90*pow((x[3]-x[2]*x[2]),2) + pow((1 - x[2]),2) +
                        10.1*pow((x[1] -1),2) + pow((x[3]-1),2));// + 19.8*(x[1] -1)*(x[3] -1));
                }
};

class DeJongF1 : public EvoTest
{
        public:
                DeJongF1(int i,char*f,int d) : EvoTest(i,f,d){}
                double run(double* x,int n = 3){
                        double sum=0;
                        
                        for(int i=0;i<n;i++){
                                sum += x[i]*x[i]; 
                        }
                        return (-1)*sum;
                }
};

class DeJongF2 : public EvoTest
{
        public:
                DeJongF2(int i,char*f,int d) : EvoTest(i,f,d){}
                double run(double* x,int n = 2){
                        return (-100)*(((x[0]*x[0]) - x[1])*((x[0]*x[0]) - x[1]) + ((1-x[0])*(1-x[0])));
                }
};

class DeJongF3 : public EvoTest
{
        public:
                DeJongF3(int i,char*f,int d) : EvoTest(i,f,d){}
                double run(double* x,int n = 5){
                        double sum=0;
                                for(int i=0;i<n;i++)
                                        sum += int(x[i]); 
                        return (-1)*sum;
                }
};

class DeJongF4 : public EvoTest
{
        public:
                DeJongF4(int i,char*f,int d) : EvoTest(i,f,d){}
                double run(double* x,int n = 30){
                        double sum=0;
                                for(int i=0;i<n;i++)
                                        sum += i*x[i]*x[i]*x[i]*x[i]; 
                        return (-1)*sum;
                }
};

class EvoGen
{
        public:
                EvoGen(double v,double l,double u){ /*cout << "Kreator" << endl;*/
                        value = v;
                        lbound = l;
                        ubound = u;
                        }
                EvoGen(const EvoGen& gen){ 
                        value = gen.value;
                        lbound = gen.lbound;
                        ubound = gen.ubound;
                        /*cout << " Kopy " << endl; */}
                        
                ~EvoGen(){/*cout << "Dest" << endl; */}
                
                friend ostream& operator<<(ostream& os, const EvoGen& eg){
                        return os <<"# "<< (double)(eg.value)<< " " <<(double)(eg.lbound) << " " << (double)(eg.ubound); }
                
                double value;
                double ubound;
                double lbound;
};

template<typename T>
class EvoGenotype : public std::vector<T>
{
        public:
                EvoGenotype(unsigned int size, const char* filename){
                                
                        fitness = 0;
                        cfitness = 0;
                        rfitness = 0;
                        generation = 0;
                        
                        double lb, ub = 0;
                        reserve(size); 
                        ifstream in(filename);
                        
                        string line;
                        
                        while(getline(in,line)){
                                istringstream s(line);
                                s >> lb >> ub ;
                                push_back(T(0,lb,ub));
                        }
                        
                }
                
                EvoGenotype() {
                        fitness = 0;
                        cfitness = 0;
                        rfitness = 0;
                        generation = 0;
                }
                        
                ~EvoGenotype(){}
                        
                
                friend ostream& operator<<(ostream& os, EvoGenotype<T>& eg){
                        typename EvoGenotype<T>::iterator it = eg.begin();
                                while(it != eg.end())
                                        os << *it++ << endl;
                        return os; 
                }
                void show(){
                        typename EvoGenotype<T>::iterator it = begin();
                        while(it != end())
                                cout << *it++ << endl;
                }
                
                void addGen(double v,double lb, double ub){
                //      cout << "addGen: " << v << " "<< lb << " " << ub << endl;
                        push_back(T(v,lb,ub));
                }
                
                double fitness;
                double cfitness;
                double rfitness;
                unsigned int generation;
                
};

template<class T>
class EvoPopulation : public std::list<T>
{
        public:
                EvoPopulation(){ 
                        it_best = begin();
                        it_worst = end(); 
                        worst = 10000;
                        best = 0;
                        randmachine = new EvoRandomizer<T>;
                }
                ~EvoPopulation(){}
                        
                void seed(){
                        typename EvoPopulation<T>::iterator it = begin();
                        typename T::iterator it_genotype;
                        while(it != end()){
                                it_genotype = (*it).begin();
                                while(it_genotype != (*it).end() ){
                                        (*it_genotype).value = randmachine->random((*it_genotype).lbound, (*it_genotype).ubound);
                                        it_genotype++;
                                }
                                it++;
                        }
                }
                
                friend ostream& operator<<(ostream& os, EvoPopulation<T>& ep){
                        typename EvoPopulation<T>::iterator it = ep.begin();
                                while(it != ep.end())
                                        os << "<GENOTYPE>" << endl << *it++ << "</GENOTYPE>" << endl ;//<< endl;
                        return os; 
                }
                
                void show(){
                        int i =0;
                        typename EvoPopulation<T>::iterator it = begin();
                        while(it != end()){
                                cout << i++ << ":" << (*it).fitness << " " << (*it).rfitness << " " << (*it).cfitness << " " <<(*it).generation <<endl;
                                (*it++).show();
                        }
                        cout << "Najlepszy :"<< best << endl << "Najgorszy :" << worst << endl;
                }
                
                double best;
                double worst;
                
                typename EvoPopulation<T>::iterator it_best;
                typename EvoPopulation<T>::iterator it_worst;
        private:
                EvoRandomizer<T>* randmachine;
};


// ----------------------------------------------------------------------------------------

//----------------RANDOMIZER-----------------------

//class DoubleRandomizer : public 
template<class T>
class EvoRandomizer
{
        public:
                int int_rand(int low, int height){ return ((int)(std::rand()%(height-low)) + low);}
                
                double random(double ubound, double lbound){
                //      cout << "dziala" << endl;
                        return (((double)(std::rand()%1000)/1000.0)*(ubound-lbound)+lbound);
                }
};

template<> class EvoRandomizer< EvoGenotype<EvoGen*> >
{
        public:
                int int_rand(int low, int height){ return ((int)(std::rand()%(height-low)) + low);}
                
                double random(double ubound, double lbound){
                        return (((double)(std::rand()%1000)/1000.0)*(ubound-lbound)+lbound);
                }
};

template<> class EvoRandomizer< EvoGenotype<EvoGen> >
{
        public:
                int int_rand(int low, int height){ return ((int)(std::rand()%(height-low)) + low);}
                
                double random(double lbound, double ubound){
                        return (((double)(rand()%1000)/1000.0)*(ubound-lbound)+lbound);
                }
};

template<typename type>
class EvoProcess
{
        public:
                EvoProcess(){}
                virtual ~EvoProcess(){} 
                virtual void command(){ cout << "Base" <<endl; }// const = 0;
                virtual void command(type&){ cout << "Base" <<endl; } //const = 0;
                virtual void command(type&,type&){ cout << "Base" <<endl; } //const = 0;
                virtual void command(EvoPopulation<type>&){ cout << "Base" << endl; }
                virtual void command(EvoPopulation<type>&,EvoPopulation<type>&){ cout << "Base" << endl; }
};

/*
template<typename type>
inline void EvoProcess<type>::command() const { cout << "Base" <<endl;}

template<typename type>
inline void EvoProcess<type>::command(type&) const { cout << "Base1" <<endl;}

template<typename type>
inline void EvoProcess<type>::command(type&,type&) const { cout << "Base2" <<endl;}
*/

template<typename type>
class EvoCodec
{
        public:
                EvoCodec() : size(0){}
                ~EvoCodec(){}
                
                unsigned int size;
                double* valueArray;
                        
                double* decode(type& genom){
                        size = genom.size();
                        valueArray = new double[size];
                        for(unsigned int i=0;i<size;i++)
                                valueArray[i] = genom[i].value;
                        return valueArray;
                }
};

template<typename type>
class EvoEvaluator : public EvoProcess<type>
{
        public:
                EvoEvaluator(EvoTest* t) : test(t), decoder(new EvoCodec<type>) {}
                ~EvoEvaluator(){}
                        
        virtual void command(EvoPopulation<type>& pop){
                        pop.worst = 100000;
                        pop.best = -100000;
                        typename EvoPopulation<type>::iterator it = pop.begin();
                        while(it != pop.end()){
                                (*it).fitness = test->run(decoder->decode(*it),(*it).size());
                        //      cout <<"Fitness ="<<(*it).fitness << endl;
                                if(pop.worst > (*it).fitness){
                                        pop.worst = (*it).fitness;
                                        pop.it_worst = it;
                                }
                                if(pop.best < (*it).fitness){
                                        pop.best = (*it).fitness;
                                        pop.it_best = it;
                                }
                                it++;
                        }
                }
        
        private:
                EvoTest* test;
                EvoCodec<type>* decoder;
};
/*
template<typename type>
class EvoEvaluator : public EvoProcess<type>
{
        public:
                EvoEvaluator(double evalfunction(double[],int)) : predicatLikeFunction(evalfunction), decoder(new EvoCodec<type>) {}
                ~EvoEvaluator(){}
                        
        virtual void command(EvoPopulation<type>& pop){ //cout << "Evaluator command" << endl;
                        pop.worst = 1000;
                        pop.best = -1000;
                        typename EvoPopulation<type>::iterator it = pop.begin();
                        while(it != pop.end()){
                                (*it).fitness = predicatLikeFunction(decoder->decode(*it),(*it).size());
                                
                                if(pop.worst > (*it).fitness){
                                        pop.worst = (*it).fitness;
                                        pop.it_worst = it;
                                }
                                if(pop.best < (*it).fitness){
                                        pop.best = (*it).fitness;
                                        pop.it_best = it;
                                }
                                it++;
                        }
                }
        
        private:
                double (*predicatLikeFunction)(double[],int);
                EvoCodec<type>* decoder;
};
*/
template<class T>
class EvoProcessList;
        
template<typename type>
class EvoSelector : public EvoProcess<type>
{

        public:
                EvoSelector(const EvoProcessList<type>& plist) 
                {
                        r = 0;
                        first = 0;
                        sum = 0;
                        randmachine = new EvoRandomizer<type>;
                        processList = plist;
                }
                ~EvoSelector(){}
                
                void command(EvoPopulation<type>& pop){
                        sum = 0;
                        
                //      cout << "Selector command" << endl;
                        typename EvoPopulation<type>::iterator it = pop.begin();
                        typename EvoPopulation<type>::iterator it_temp;
                        
                        while(it != pop.end())
                                sum += ((*it++).fitness - pop.worst) ;
                        
        
                        it = pop.begin();
                        while(it != pop.end())
                                (*it).rfitness = ((*it++).fitness - pop.worst + 1)/sum;
                        
                        it = pop.begin();
                        it_temp = it;
                        
                        (*it).cfitness = (*it).rfitness;
                        it++;
                        
                        while(it != pop.end())
                                (*it).cfitness = (*it_temp++).cfitness + (*it++).rfitness;
                        
                        double p = 0;
                        typename EvoPopulation<type>::iterator it_inside = pop.begin();
//                      typename EvoPopulation<type>::iterator it_mem = pop.begin(); // ten wylaczony test
                        
                        it = pop.begin();
                        bool flag = true;
                        first =0;
                        while(it != pop.end()){
                                it++;
                                p = randmachine->random(0,1);
                                it_inside = pop.begin();
                                
                                it_temp = it_inside;
                                flag = true;
                                it_temp++;
                                if( p < (*it_inside).cfitness ){
                                        sendToProcess((*it_inside));
                                        
                                }else{
                                        while( it_temp != pop.end() && (flag==true)){
                                        //      cout << "TEST1" << endl;
                                                if( (p >= (*it_inside).cfitness) && (p < (*it_temp).cfitness)){
                                                        sendToProcess((*it_temp));
                                                        flag = false;
                                                }
                                                it_inside++;
                                                it_temp++;
                                        }
                                }               
                        }
                }
                
                void sendToProcess(type& l){
                        //cout << "TEST2"<<endl;
                        ++first;
                        if( first % 2 == 0 ){
                        //      cout << "TEST3"<<endl;
                                if(l.fitness > r->fitness){
                                        l.generation += 1;
                                //      l.show();
                                //      r->show();
                                        processList.start(l,*r);
                                //      l.show();
                                //      r->show();
                                }else{
                                        r->generation += 1;
                                //      l.show();
                                //      r->show();
                                        processList.start(*r,l);
                                //      l.show();
                                //      r->show();
                                }
                        }else{
                        //      cout << "TEST4"<<endl;
                                r = &l;
                        }
                }
                        
                
        private:
                EvoProcessList<type> processList; 
                EvoRandomizer<type>* randmachine;
        
                double sum;
                int first;

                type* r;

};

template<typename type>
class EvoOperator : public EvoProcess<type>
{
        public:
                EvoOperator(){}
                ~EvoOperator(){}
                        
                virtual void command(){};
};

template<typename type>
class EvoMutation : public EvoOperator<type>
{
        public:
                EvoMutation(double d) : randmachine(new EvoRandomizer<type>) {
                        pm = d;
                        cout << "#Mutation Creation" << endl;
                }
                ~EvoMutation(){ cout << "#Mutation Destruction" <<endl;}
                
                virtual void command(type& l, type& r){
//                      typename type::iterator it = r.begin();
                        control = randmachine->random(0,1);
                        if(pm > control){
                                point = randmachine->int_rand(0,r.size());
                                (r[point]).value =  randmachine->random(r[point].lbound,r[point].ubound);
                        }
                }
        private:
                EvoRandomizer<type>* randmachine;
                double pm;
                double control;
                int point;
};


template<typename type>
class EvoUnEqualMutation : public EvoOperator<type>
{
        public:
                EvoUnEqualMutation(double d,double bi,unsigned int Ti) : randmachine(new EvoRandomizer<type>) {
                        pm = d;
                        b = bi;
                        T = Ti;
                        cout << "#Unequal Mutation Creation" << endl;
                        }
                ~EvoUnEqualMutation(){ cout << "#Unequal Mutation Destruction" <<endl;}
                
                virtual void command(type& l, type& r){
                //      cout << "UNEQMUTATION" << endl;
                        typename type::iterator it = r.begin();
                        while( it != r.end() ){
                                rnd = randmachine->random(0,1);
                                if(pm > rnd){
                                        rnd = randmachine->random(0,1);
                                        if(rnd < 0.5)
                                                (*it).value += delta_function(r.generation,(*it).ubound - (*it).value);
                                        else
                                                (*it).value -= delta_function(r.generation,(*it).value - (*it).lbound);
                                }
                                it++;
                        }
                }
                
                double delta_function(unsigned int t, double y)
                {
                        if(t > T) t=T-1;
                        
                        rnd = randmachine->random(0,1);
                        return y*(1-pow(rnd,(1-(t/T)*b)));
                }
        private:
                EvoRandomizer<type>* randmachine;
                double pm;
                double b;
                double rnd;
                unsigned int T;
                
};


template<typename type>
class EvoCrossover : public EvoOperator<type>
{
        public:
                EvoCrossover(double p) : randmachine(new EvoRandomizer<type>) { 
                        pc = p;
                        cout << "#Crossover Creation" << endl;
                }
                ~EvoCrossover(){ cout << "#Crossover Destruction" <<endl;}
                
                void command(type& l, type& r){
//                      typename type::iterator it = r.begin();
//                      typename type::iterator it_l = l.begin();
                        
                        if(pc > randmachine->random(0,1)){
                                unsigned int lpoint = randmachine->int_rand(0,r.size());
                                unsigned int rpoint = randmachine->int_rand(0,r.size());
                                unsigned int temp = lpoint;
                                
                                if(lpoint > rpoint){
                                        lpoint = rpoint;
                                        rpoint = temp;
                                }
                        //      if(rpoint - lpoint > 0.8*r.size())
                        //              rpoint = lpoint + ((int)(0.8*r.size()));
                        //      if(rpoint > r.size())
                        //              rpoint = r.size();
                                
                        //      cout << "CROSSOVER" << endl;
                        //      cout << lpoint << " " << rpoint << endl;
                        //      r.show();
                        //      cout << " " << endl;
                        //      l.show();
                        //      cout << " " << endl;
                                if(r.size()<3)
                                        (r[lpoint]).value = (l[lpoint]).value;
                                else
                                        for(;lpoint <= rpoint;lpoint++)//{
                                                (r[lpoint]).value = (l[lpoint]).value;
                        //                      cout << lpoint << endl;
                        //              }
                        //      r.show();
                        //              cout << " " << endl;
                        //      l.show();
                        //              cout << " " << endl;
                        //      cout << "CRO koniec" << endl;
                        //      l.show();
                        //              cout << endl;
                        //      r.show();
                        }
                }
        private:
                EvoRandomizer<type>* randmachine;
                double pc;
};

template<typename type>
class EvoMeanCrossover : public EvoOperator<type>
{
        public:
                EvoMeanCrossover(double p) : randmachine(new EvoRandomizer<type>) {
                        pc = p;
                        cout << "#Mean Crossover Creation" << endl;
                        }
                ~EvoMeanCrossover(){ cout << "#Crossover Destruction" <<endl;}
                
                void command(type& l, type& r){
//                      typename type::iterator it = r.begin();
//                      typename type::iterator it_l = l.begin();
                        double rnd = randmachine->random(0,1);
                        
                        if(pc > rnd){
                //              cout << "MEAN CROSSOVER" << endl;
                        //      cout << r.size() << endl;
                                int lpoint = randmachine->int_rand(0,r.size());
                                int rpoint = randmachine->int_rand(0,r.size());
                                int temp = lpoint;
                                if(lpoint > rpoint){
                                        lpoint = rpoint;
                                        rpoint = temp;
                                }
                //              cout << lpoint << " " << rpoint << endl;
                                if(r.size()<3)
                                        (r[lpoint]).value = (r[lpoint]).value + rnd*((l[lpoint]).value - (r[lpoint]).value);
                                else
                                        for(;lpoint <= rpoint;lpoint++)
                                                (r[lpoint]).value = (r[lpoint]).value + rnd*((l[lpoint]).value - (r[lpoint]).value);
                                        //      cout << lpoint << endl;
                                        
                //              cout << "koniec" << endl;
                        //      l.show();
                        //              cout << endl;
                        //      r.show();
                        }
                }
        private:
                EvoRandomizer<type>* randmachine;
                double pc;
};

template<class T>
class EvoProcessList : public std::list< EvoProcess<T>* >
{
        public:
                EvoProcessList(){}
                ~EvoProcessList(){}
                        
                void start(T& first, T& second){
                        typename EvoProcessList<T>::iterator it = begin();
                        while(it != end() ){
                                (*it)->command(first, second);
                                it++;
                        }
        //              cout << "End Process TwoArg" << endl;
                }
                
                void start(EvoPopulation<T>& first){
                        typename EvoProcessList<T>::iterator it = begin();
                        while(it != end() ){
                                (*it)->command(first);
                                it++;
                        }
        //              cout << "End Process OneArg" << endl;
                }
        
};

#endif // EVOPOPULATION_H //

---