testmultiga.cpp

Go to the documentation of this file.

#include <iostream>
#include "SimpleSelect.h"
#include "UniformRNG.h"
#include "gentypes.h"
#include "BinaryPopulation.h"
#include "StandardPropagation.h"
#include "BinaryTranscribe.h"
#include "AnnealingGA.h"
#include "ParetoGA.h"
#include "TestObjective.h"
#include "TestObjective2.h"
#include "BinaryTournamentSelect.h"
#include <boost/numeric/ublas/vector.hpp>
#include <boost/numeric/ublas/io.hpp>
#include <boost/numeric/ublas/matrix_proxy.hpp>
#include <boost/bind.hpp>
#include <boost/shared_ptr.hpp>
#include <fstream>

using namespace std;
int main()
{
        UniformRNG Random;
        const int popsize = 20;
        typedef boost::shared_ptr<GeneralObjective> pCGeneralObjective;
        const double inittemp = 1;
        const int annealgen = 5;
        const double ratio = 10;
        const int maxgen = 20;
        const int nparam = 2;
        
        ttranscribed basevalues(nparam);
        ttranscribed stepsizes(nparam);
        tsizev genesizes(nparam);
        basevalues(0) = -10;
        stepsizes(0) = 0.02;
        genesizes(0) = 10;
        basevalues(1) = -10;
        stepsizes(1) = 0.02;
        genesizes(1) = 10;
        const int genesize = ublas::sum(genesizes);
        boost::shared_ptr<TestObjective> Objective(new TestObjective());
        boost::shared_ptr<TestObjective2> Objective2(new TestObjective2());

        std::vector<int> Indices(nparam,0);
        for (int i = 0; i < nparam; ++i)
                Indices.at(i) = i;
        vector<pCGeneralObjective> ObjVector;
        ObjVector.push_back(Objective);
        ObjVector.push_back(Objective2);
        
        BinaryPopulation Population(popsize,genesize,&Random,true);
        BinaryTournamentSelect Select(&Random,boost::bind(&GeneralPopulation::GetProbabilities,boost::ref(Population)),
                boost::bind(&GeneralPopulation::GetCrowdingDistances,boost::ref(Population)));
        BinaryTranscribe Transcribe(basevalues,stepsizes,genesizes);
        StandardPropagation Propagator(&Select,&Population,&Random);
        tprobabilityv probabilities(popsize);
        double sum=0;
        
        const double mutationprob = 0.1;
        const double crossoverprob = 0.6;
        Propagator.SetParams(mutationprob,crossoverprob);
        
        ttranscribed transcribed;
        ParetoGA GA(&Propagator,&Population,&Transcribe,ObjVector);
        
        GeneralGA::tparamindv temp(2,Indices);
        
        GA.SetParameterIndices(temp);
        GA.SetElitist(true);
        cout << "Population initialized" << endl <<flush;
        
        //GA.SetParams(inittemp,annealgen,ratio);
        
        cout << "Pointers set" << endl <<flush;
        
        ofstream rankfile("test.ranks");
        
        for (int i = 0; i < maxgen; ++i)
        {
                cout << endl << "Iteration: " << i << endl << endl; 
                /*cout << "Transcribed: " << endl;
                for (int j = 0; j < Population.GetPopsize(); ++j)
                {
                        cout << row(Population.GetPopulation(),j) << " " << Transcribe.GetValues(row(Population.GetPopulation(),j)) << endl;
                }*/
                
                GA.DoIteration(i,i==(maxgen -1));
                cout << "Misfit: " << endl;
                GA.PrintMisfit(cout);
                GA.PrintRanks(rankfile);
        }
        ofstream frontfile("test.front");
        GA.PrintFront(frontfile);
        ofstream modelfile("test.model");
        for (int j = 0; j < Population.GetPopsize(); ++j)
        {
                for (int k = 0; k < nparam; ++k)
                {
                        modelfile << Transcribe.GetValues(row(Population.GetPopulation(),j))(k) << " ";
                }
                modelfile << endl;
        }
        //Population.PrintPopulation(cout);
        //cout << "Bestindex: " << Population.bestindex << endl << flush;
        //transcribed = Transcribe.GetValues(row(Population.Population,Population.bestindex));
        
}

---