nojhan/eodev
Archived
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity

Adding sharing - needed to modify quite a few files, like eoDistance.h

Browse source 
make_algo_scalar.h and all related files, and the like
This commit is contained in:
evomarc 2004-05-25 08:03:30 +00:00
commit 795f63b7fe
14 changed files with 244 additions and 93 deletions
Download patch file Download diff file Expand all files Collapse all files

34
eo/src/do/make_algo_scalar.h
View file

@ -39,6 +39,7 @@
#include <eoFitnessScalingSelect.h> #include <eoFitnessScalingSelect.h>
#include <eoRankingSelect.h> #include <eoRankingSelect.h>
#include <eoStochTournamentSelect.h> #include <eoStochTournamentSelect.h>
#include <eoSharingSelect.h>
// Breeders // Breeders
#include <eoGeneralBreeder.h> #include <eoGeneralBreeder.h>
@ -49,6 +50,9 @@
#include <eoReduceMerge.h> #include <eoReduceMerge.h>
#include <eoSurviveAndDie.h> #include <eoSurviveAndDie.h>
// distance
#include <utils/eoDistance.h>
// Algorithm (only this one needed) // Algorithm (only this one needed)
#include <eoEasyEA.h> #include <eoEasyEA.h>
@ -70,11 +74,18 @@
* is actually templatized here * is actually templatized here
*/ */
template <class EOT> template <class EOT>
eoAlgo<EOT> & do_make_algo_scalar(eoParser& _parser, eoState& _state, eoEvalFunc<EOT>& _eval, eoContinue<EOT>& _continue, eoGenOp<EOT>& _op) eoAlgo<EOT> & do_make_algo_scalar(eoParser& _parser, eoState& _state, eoEvalFunc<EOT>& _eval, eoContinue<EOT>& _continue, eoGenOp<EOT>& _op, eoDistance<EOT> * _dist = NULL)
{ {
// the selection // the selection : help and comment depend on whether or not a distance is passed
eoValueParam<eoParamParamType>& selectionParam = _parser.createParam(eoParamParamType("DetTour(2)"), "selection", "Selection: Roulette, Ranking(p,e), DetTour(T), StochTour(t) or Sequential(ordered/unordered)", 'S', "Evolution Engine"); std::string comment;
if (_dist == NULL)
comment = "Selection: DetTour(T), StochTour(t), Roulette, Ranking(p,e) or Sequential(ordered/unordered)";
else
comment = "Selection: DetTour(T), StochTour(t), Roulette, Ranking(p,e), Sharing(sigma_share) or Sequential(ordered/unordered)";
eoValueParam<eoParamParamType>& selectionParam = _parser.createParam(eoParamParamType("DetTour(2)"), "selection", comment, 'S', "Evolution Engine");
eoParamParamType & ppSelect = selectionParam.value(); // std::pair<std::string,std::vector<std::string> > eoParamParamType & ppSelect = selectionParam.value(); // std::pair<std::string,std::vector<std::string> >
@ -94,6 +105,23 @@ eoAlgo<EOT> & do_make_algo_scalar(eoParser& _parser, eoState& _state, eoEvalFunc
detSize = atoi(ppSelect.second[0].c_str()); detSize = atoi(ppSelect.second[0].c_str());
select = new eoDetTournamentSelect<EOT>(detSize); select = new eoDetTournamentSelect<EOT>(detSize);
} }
else if (ppSelect.first == std::string("Sharing"))
{
double nicheSize;
if (!ppSelect.second.size()) // no parameter added
{
std::cerr << "WARNING, no parameter passed to Sharing, using 0.5" << std::endl;
nicheSize = 0.5;
// put back 2 in parameter for consistency (and status file)
ppSelect.second.push_back(std::string("0.5"));
}
else // parameter passed by user as DetTour(T)
nicheSize = atof(ppSelect.second[0].c_str());
if (_dist == NULL) // no distance
throw std::runtime_error("You didn't specify a distance when calling make_algo_scalar and using sharing");
select = new eoSharingSelect<EOT>(nicheSize, *_dist);
}
else if (ppSelect.first == std::string("StochTour")) else if (ppSelect.first == std::string("StochTour"))
{ {
double p; double p;

8
eo/src/eoSelectFromWorth.h
View file

@ -26,7 +26,7 @@
#ifndef _eoSelectFromWorth_h #ifndef _eoSelectFromWorth_h
#define _eoSelectFromWorth_h #define _eoSelectFromWorth_h
#include <iostream.h>
//----------------------------------------------------------------------------- //-----------------------------------------------------------------------------
#include <eoSelectOne.h> #include <eoSelectOne.h>
#include <eoPerf2Worth.h> #include <eoPerf2Worth.h>
@ -197,6 +197,12 @@ public:
*/ */
virtual const EOT& operator()(const eoPop<EOT>& _pop) virtual const EOT& operator()(const eoPop<EOT>& _pop)
{ {
// cout << "On affiche les worths\n";
// for (unsigned i=0;
// i<perf2Worth.value().size();
// i++)
// cout << perf2Worth.value().operator[](i) << "\n";
// cout << endl;
worthIterator it = roulette_wheel( worthIterator it = roulette_wheel(
perf2Worth.value().begin(), perf2Worth.value().begin(),
perf2Worth.value().end(), perf2Worth.value().end(),

124
eo/src/eoSharing.h
View file

@ -32,65 +32,14 @@
/** Sharing is a perf2worth class that implements /** Sharing is a perf2worth class that implements
* Goldberg and Richardson's basic sharing * Goldberg and Richardson's basic sharing
*/ */
// template <class EOT, class Dist = eoQuadDistance<EOT> >
template <class EOT>
class eoSharing : public eoPerf2Worth<EOT, double>
{
public:
/** Ctor with only nicheSize: will use the default eoQuadDistance */
eoSharing(double _nicheSize) : eoPerf2Worth("Sharing"),
nicheSize(_nicheSize),
dist(repDist)
{}
eoSharing(double _nicheSize, Dist _dist) : eoPerf2Worth("Sharing"),
nicheSize(_nicheSize),
dist(_dist)
{}
/** Computes shared fitnesses
*/
void operator()(const eoPop<EOT>& _pop)
{
unsigned i, j,
pSize=_pop.size();
if (pSize <= 1)
throw std::runtime_error("Apptempt to do sharing with population of size 1");
value.resize(pSize);
std::vector<double> sim(pSize); // to hold the similarities
std::vector<double> distMatrix(pSize*(pSize-1)/2); // to hold the distances
// compute the distances
distMatrix(0,0)=0;
for (i=1; i<pSize; i++)
{
distMatrix(i,i)=0;
for (j=0; j<i; j++)
{
distMatrix(i,j) = distMatrix(j,i) = dist(_pop[i], _pop[j]);
}
}
// compute the similarities
for (i=0; i<pSize; i++)
{
double sum=0.0;
for (j=0; j<pSize; j++)
sum += distMatrix(i,j);
sim[i] = sum;
}
// now set the worthes values
for (i = 0; i < _pop.size(); ++i)
value()[i]=_pop[i].fitness()/sim[i];
}
// First a helper class
// helper class to hold distances // helper class to hold distances
class dMatrix : public std::vector<double> class dMatrix : public std::vector<double>
{ {
public: public:
// Ctor : sets size // Ctor : sets size
dMatrix(unsigned _s) : std::vector<double>(_s*(_s-1)), rSize(_s) {} dMatrix(unsigned _s) : std::vector<double>(_s*_s), rSize(_s) {}
/** simple accessor */ /** simple accessor */
double operator()(unsigned _i, unsigned _j) const double operator()(unsigned _i, unsigned _j) const
@ -121,11 +70,76 @@ class eoSharing : public eoPerf2Worth<EOT, double>
unsigned rSize; // row size (== number of columns!) unsigned rSize; // row size (== number of columns!)
}; };
// template <class EOT, class Dist = eoQuadDistance<EOT> >
template <class EOT>
class eoSharing : public eoPerf2Worth<EOT>
{
public:
/* Ctor requires a distance - cannot have a default distance! */
eoSharing(double _nicheSize, eoDistance<EOT> & _dist) : eoPerf2Worth<EOT>("Sharing"),
nicheSize(_nicheSize),
dist(_dist)
{}
/** Computes shared fitnesses
*/
void operator()(const eoPop<EOT>& _pop)
{
unsigned i, j,
pSize=_pop.size();
if (pSize <= 1)
throw std::runtime_error("Apptempt to do sharing with population of size 1");
value().resize(pSize);
std::vector<double> sim(pSize); // to hold the similarities
dMatrix distMatrix(pSize*(pSize-1)/2); // to hold the distances
// compute the similarities (wrong name for distMatrix, I know)
distMatrix(0,0)=1;
for (i=1; i<pSize; i++)
{
distMatrix(i,i)=1;
for (j=0; j<i; j++)
{
double d = dist(_pop[i], _pop[j]);
distMatrix(i,j) =
distMatrix(j,i) = ( d>nicheSize ? 0 : 1-(d/nicheSize) );
}
}
// cout << "Matrice des similarités\n";
// for (i=0; i<pSize; i++)
// {
// for (j=0; j<pSize; j++)
// {
// cout << distMatrix(i,j) << " ";
// }
// cout << "\n";
// }
// cout << endl;
// cout << "Les similarités cumulées\n";
// compute the cumulated similarities
for (i=0; i<pSize; i++)
{
double sum=0.0;
for (j=0; j<pSize; j++)
sum += distMatrix(i,j);
sim[i] = sum;
// cout << sim[i] << " ";
}
// cout << endl;
// now set the worthes values
for (i = 0; i < _pop.size(); ++i)
value()[i]=_pop[i].fitness()/sim[i];
}
// private data of class eoSharing // private data of class eoSharing
private: private:
double nicheSize; double nicheSize;
eoQuadDistance<EOT> repDist; // default distance eoDistance<EOT> & dist; // specific distance
eoDistance & dist; // allows to pass a specific distance
}; };
#endif #endif

54
eo/src/eoSharingSelect.h Normal file
View file

@ -0,0 +1,54 @@
// -*- mode: c++; c-indent-level: 4; c++-member-init-indent: 8; comment-column: 35; -*-
//-----------------------------------------------------------------------------
// eoSharingSelect.h
// (c) GeNeura Team, 1998, Maarten Keijzer 2000, Marc Schoenauer 2001
/*
This library is free software; you can redistribute it and/or
modify it under the terms of the GNU Lesser General Public
License as published by the Free Software Foundation; either
version 2 of the License, or (at your option) any later version.
This library 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
Lesser General Public License for more details.
You should have received a copy of the GNU Lesser General Public
License along with this library; if not, write to the Free Software
Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
Contact: Marc.Schoenauer@polytechnique.fr
mak@dhi.dk
*/
//-----------------------------------------------------------------------------
#ifndef eoSharingSelect_h
#define eoSharingSelect_h
//-----------------------------------------------------------------------------
#include <eoSelectFromWorth.h>
#include <eoSharing.h>
/** eoRankingSelect: select an individual by roulette wheel on its rank
* is an eoRouletteWorthSelect, i.e. a selector using a std::vector of worthes
* rather than the raw fitness (see eoSelectFromWorth.h)
* uses an internal eoRanking object which is an eoPerf2Worth<EOT, double>
*/
template <class EOT>
class eoSharingSelect: public eoRouletteWorthSelect<EOT, double>
{
public:
/** Ctor:
* @param _s the sigma_share
*/
eoSharingSelect(double _sigma, eoDistance<EOT> & _dist):
eoRouletteWorthSelect<EOT, double>(sharing), sharing(_sigma, _dist) {}
private :
eoSharing<EOT> sharing; // derived from eoPerf2Worth
};
#endif

12
eo/src/es/make_algo_scalar_es.cpp
View file

@ -51,34 +51,34 @@
// Algo // Algo
/////// ///////
eoAlgo<eoEsSimple<double> >& make_algo_scalar(eoParser& _parser, eoState& _state, eoEvalFunc<eoEsSimple<double> >& _eval, eoContinue<eoEsSimple<double> >& _continue, eoGenOp<eoEsSimple<double> >& _op) eoAlgo<eoEsSimple<double> >& make_algo_scalar(eoParser& _parser, eoState& _state, eoEvalFunc<eoEsSimple<double> >& _eval, eoContinue<eoEsSimple<double> >& _continue, eoGenOp<eoEsSimple<double> >& _op, eoDistance<eoEsSimple<double> >* _dist)
{ {
return do_make_algo_scalar(_parser, _state, _eval, _continue, _op); return do_make_algo_scalar(_parser, _state, _eval, _continue, _op);
} }
eoAlgo<eoEsSimple<eoMinimizingFitness> >& make_algo_scalar(eoParser& _parser, eoState& _state, eoEvalFunc<eoEsSimple<eoMinimizingFitness> >& _eval, eoContinue<eoEsSimple<eoMinimizingFitness> >& _continue, eoGenOp<eoEsSimple<eoMinimizingFitness> >& _op) eoAlgo<eoEsSimple<eoMinimizingFitness> >& make_algo_scalar(eoParser& _parser, eoState& _state, eoEvalFunc<eoEsSimple<eoMinimizingFitness> >& _eval, eoContinue<eoEsSimple<eoMinimizingFitness> >& _continue, eoGenOp<eoEsSimple<eoMinimizingFitness> >& _op, eoDistance<eoEsSimple<eoMinimizingFitness> >* _dist)
{ {
return do_make_algo_scalar(_parser, _state, _eval, _continue, _op); return do_make_algo_scalar(_parser, _state, _eval, _continue, _op);
} }
////////////// //////////////
eoAlgo<eoEsStdev<double> >& make_algo_scalar(eoParser& _parser, eoState& _state, eoEvalFunc<eoEsStdev<double> >& _eval, eoContinue<eoEsStdev<double> >& _continue, eoGenOp<eoEsStdev<double> >& _op) eoAlgo<eoEsStdev<double> >& make_algo_scalar(eoParser& _parser, eoState& _state, eoEvalFunc<eoEsStdev<double> >& _eval, eoContinue<eoEsStdev<double> >& _continue, eoGenOp<eoEsStdev<double> >& _op, eoDistance<eoEsStdev<double> >* _dist)
{ {
return do_make_algo_scalar(_parser, _state, _eval, _continue, _op); return do_make_algo_scalar(_parser, _state, _eval, _continue, _op);
} }
eoAlgo<eoEsStdev<eoMinimizingFitness> >& make_algo_scalar(eoParser& _parser, eoState& _state, eoEvalFunc<eoEsStdev<eoMinimizingFitness> >& _eval, eoContinue<eoEsStdev<eoMinimizingFitness> >& _continue, eoGenOp<eoEsStdev<eoMinimizingFitness> >& _op) eoAlgo<eoEsStdev<eoMinimizingFitness> >& make_algo_scalar(eoParser& _parser, eoState& _state, eoEvalFunc<eoEsStdev<eoMinimizingFitness> >& _eval, eoContinue<eoEsStdev<eoMinimizingFitness> >& _continue, eoGenOp<eoEsStdev<eoMinimizingFitness> >& _op, eoDistance<eoEsStdev<eoMinimizingFitness> >* _dist)
{ {
return do_make_algo_scalar(_parser, _state, _eval, _continue, _op); return do_make_algo_scalar(_parser, _state, _eval, _continue, _op);
} }
/////////////// ///////////////
eoAlgo<eoEsFull<double> >& make_algo_scalar(eoParser& _parser, eoState& _state, eoEvalFunc<eoEsFull<double> >& _eval, eoContinue<eoEsFull<double> >& _continue, eoGenOp<eoEsFull<double> >& _op) eoAlgo<eoEsFull<double> >& make_algo_scalar(eoParser& _parser, eoState& _state, eoEvalFunc<eoEsFull<double> >& _eval, eoContinue<eoEsFull<double> >& _continue, eoGenOp<eoEsFull<double> >& _op, eoDistance<eoEsFull<double> >* _dist)
{ {
return do_make_algo_scalar(_parser, _state, _eval, _continue, _op); return do_make_algo_scalar(_parser, _state, _eval, _continue, _op);
} }
eoAlgo<eoEsFull<eoMinimizingFitness> >& make_algo_scalar(eoParser& _parser, eoState& _state, eoEvalFunc<eoEsFull<eoMinimizingFitness> >& _eval, eoContinue<eoEsFull<eoMinimizingFitness> >& _continue, eoGenOp<eoEsFull<eoMinimizingFitness> >& _op) eoAlgo<eoEsFull<eoMinimizingFitness> >& make_algo_scalar(eoParser& _parser, eoState& _state, eoEvalFunc<eoEsFull<eoMinimizingFitness> >& _eval, eoContinue<eoEsFull<eoMinimizingFitness> >& _continue, eoGenOp<eoEsFull<eoMinimizingFitness> >& _op, eoDistance<eoEsFull<eoMinimizingFitness> >* _dist)
{ {
return do_make_algo_scalar(_parser, _state, _eval, _continue, _op); return do_make_algo_scalar(_parser, _state, _eval, _continue, _op);
} }

8
eo/src/es/make_algo_scalar_real.cpp
View file

@ -49,13 +49,13 @@
// Algo // Algo
/////// ///////
eoAlgo<eoReal<double> >& make_algo_scalar(eoParser& _parser, eoState& _state, eoEvalFunc<eoReal<double> >& _eval, eoContinue<eoReal<double> >& _continue, eoGenOp<eoReal<double> >& _op) eoAlgo<eoReal<double> >& make_algo_scalar(eoParser& _parser, eoState& _state, eoEvalFunc<eoReal<double> >& _eval, eoContinue<eoReal<double> >& _continue, eoGenOp<eoReal<double> >& _op, eoDistance<eoReal<double> >* _dist)
{ {
return do_make_algo_scalar(_parser, _state, _eval, _continue, _op); return do_make_algo_scalar(_parser, _state, _eval, _continue, _op, _dist);
} }
eoAlgo<eoReal<eoMinimizingFitness> >& make_algo_scalar(eoParser& _parser, eoState& _state, eoEvalFunc<eoReal<eoMinimizingFitness> >& _eval, eoContinue<eoReal<eoMinimizingFitness> >& _continue, eoGenOp<eoReal<eoMinimizingFitness> >& _op) eoAlgo<eoReal<eoMinimizingFitness> >& make_algo_scalar(eoParser& _parser, eoState& _state, eoEvalFunc<eoReal<eoMinimizingFitness> >& _eval, eoContinue<eoReal<eoMinimizingFitness> >& _continue, eoGenOp<eoReal<eoMinimizingFitness> >& _op, eoDistance<eoReal<eoMinimizingFitness> >* _dist)
{ {
return do_make_algo_scalar(_parser, _state, _eval, _continue, _op); return do_make_algo_scalar(_parser, _state, _eval, _continue, _op, _dist);
} }

13
eo/src/es/make_es.h
View file

@ -52,6 +52,7 @@
#include <utils/eoCheckPoint.h> #include <utils/eoCheckPoint.h>
#include <eoGenOp.h> #include <eoGenOp.h>
#include <eoPop.h> #include <eoPop.h>
#include <utils/eoDistance.h>
#include <es/eoEsSimple.h> // one Sigma per individual #include <es/eoEsSimple.h> // one Sigma per individual
#include <es/eoEsStdev.h> // one sigmal per object variable #include <es/eoEsStdev.h> // one sigmal per object variable
@ -119,14 +120,14 @@ eoCheckPoint<eoEsFull<eoMinimizingFitness> >& make_checkpoint(eoParser& _parser,
// the algo // the algo
eoAlgo<eoEsSimple<double> >& make_algo_scalar(eoParser& _parser, eoState& _state, eoEvalFunc<eoEsSimple<double> >& _eval, eoContinue<eoEsSimple<double> >& _ccontinue, eoGenOp<eoEsSimple<double> >& _op); eoAlgo<eoEsSimple<double> >& make_algo_scalar(eoParser& _parser, eoState& _state, eoEvalFunc<eoEsSimple<double> >& _eval, eoContinue<eoEsSimple<double> >& _ccontinue, eoGenOp<eoEsSimple<double> >& _op, eoDistance<eoEsSimple<double> >* _dist = NULL);
eoAlgo<eoEsSimple<eoMinimizingFitness> >& make_algo_scalar(eoParser& _parser, eoState& _state, eoEvalFunc<eoEsSimple<eoMinimizingFitness> >& _eval, eoContinue<eoEsSimple<eoMinimizingFitness> >& _ccontinue, eoGenOp<eoEsSimple<eoMinimizingFitness> >& _op); eoAlgo<eoEsSimple<eoMinimizingFitness> >& make_algo_scalar(eoParser& _parser, eoState& _state, eoEvalFunc<eoEsSimple<eoMinimizingFitness> >& _eval, eoContinue<eoEsSimple<eoMinimizingFitness> >& _ccontinue, eoGenOp<eoEsSimple<eoMinimizingFitness> >& _op, eoDistance<eoEsSimple<eoMinimizingFitness> >* _dist = NULL);
eoAlgo<eoEsStdev<double> >& make_algo_scalar(eoParser& _parser, eoState& _state, eoEvalFunc<eoEsStdev<double> >& _eval, eoContinue<eoEsStdev<double> >& _ccontinue, eoGenOp<eoEsStdev<double> >& _op); eoAlgo<eoEsStdev<double> >& make_algo_scalar(eoParser& _parser, eoState& _state, eoEvalFunc<eoEsStdev<double> >& _eval, eoContinue<eoEsStdev<double> >& _ccontinue, eoGenOp<eoEsStdev<double> >& _op, eoDistance<eoEsStdev<double> >* _dist = NULL);
eoAlgo<eoEsStdev<eoMinimizingFitness> >& make_algo_scalar(eoParser& _parser, eoState& _state, eoEvalFunc<eoEsStdev<eoMinimizingFitness> >& _eval, eoContinue<eoEsStdev<eoMinimizingFitness> >& _ccontinue, eoGenOp<eoEsStdev<eoMinimizingFitness> >& _op); eoAlgo<eoEsStdev<eoMinimizingFitness> >& make_algo_scalar(eoParser& _parser, eoState& _state, eoEvalFunc<eoEsStdev<eoMinimizingFitness> >& _eval, eoContinue<eoEsStdev<eoMinimizingFitness> >& _ccontinue, eoGenOp<eoEsStdev<eoMinimizingFitness> >& _op, eoDistance<eoEsStdev<eoMinimizingFitness> >* _dist = NULL);
eoAlgo<eoEsFull<double> >& make_algo_scalar(eoParser& _parser, eoState& _state, eoEvalFunc<eoEsFull<double> >& _eval, eoContinue<eoEsFull<double> >& _ccontinue, eoGenOp<eoEsFull<double> >& _op); eoAlgo<eoEsFull<double> >& make_algo_scalar(eoParser& _parser, eoState& _state, eoEvalFunc<eoEsFull<double> >& _eval, eoContinue<eoEsFull<double> >& _ccontinue, eoGenOp<eoEsFull<double> >& _op, eoDistance<eoEsFull<double> >* _dist = NULL);
eoAlgo<eoEsFull<eoMinimizingFitness> >& make_algo_scalar(eoParser& _parser, eoState& _state, eoEvalFunc<eoEsFull<eoMinimizingFitness> >& _eval, eoContinue<eoEsFull<eoMinimizingFitness> >& _ccontinue, eoGenOp<eoEsFull<eoMinimizingFitness> >& _op); eoAlgo<eoEsFull<eoMinimizingFitness> >& make_algo_scalar(eoParser& _parser, eoState& _state, eoEvalFunc<eoEsFull<eoMinimizingFitness> >& _eval, eoContinue<eoEsFull<eoMinimizingFitness> >& _ccontinue, eoGenOp<eoEsFull<eoMinimizingFitness> >& _op, eoDistance<eoEsFull<eoMinimizingFitness> >* _dist = NULL);
// run // run
void run_ea(eoAlgo<eoEsSimple<double> >& _ga, eoPop<eoEsSimple<double> >& _pop); void run_ea(eoAlgo<eoEsSimple<double> >& _ga, eoPop<eoEsSimple<double> >& _pop);

5
eo/src/es/make_real.h
View file

@ -52,6 +52,7 @@
#include <utils/eoCheckPoint.h> #include <utils/eoCheckPoint.h>
#include <eoGenOp.h> #include <eoGenOp.h>
#include <eoPop.h> #include <eoPop.h>
#include <utils/eoDistance.h>
#include <es/eoRealInitBounded.h> #include <es/eoRealInitBounded.h>
#include <es/eoReal.h> #include <es/eoReal.h>
@ -85,9 +86,9 @@ eoCheckPoint<eoReal<eoMinimizingFitness> >& make_checkpoint(eoParser& _parser, e
// the algo // the algo
eoAlgo<eoReal<double> >& make_algo_scalar(eoParser& _parser, eoState& _state, eoEvalFunc<eoReal<double> >& _eval, eoContinue<eoReal<double> >& _ccontinue, eoGenOp<eoReal<double> >& _op); eoAlgo<eoReal<double> >& make_algo_scalar(eoParser& _parser, eoState& _state, eoEvalFunc<eoReal<double> >& _eval, eoContinue<eoReal<double> >& _ccontinue, eoGenOp<eoReal<double> >& _op, eoDistance<eoReal<double> >* _dist = NULL);
eoAlgo<eoReal<eoMinimizingFitness> >& make_algo_scalar(eoParser& _parser, eoState& _state, eoEvalFunc<eoReal<eoMinimizingFitness> >& _eval, eoContinue<eoReal<eoMinimizingFitness> >& _ccontinue, eoGenOp<eoReal<eoMinimizingFitness> >& _op); eoAlgo<eoReal<eoMinimizingFitness> >& make_algo_scalar(eoParser& _parser, eoState& _state, eoEvalFunc<eoReal<eoMinimizingFitness> >& _eval, eoContinue<eoReal<eoMinimizingFitness> >& _ccontinue, eoGenOp<eoReal<eoMinimizingFitness> >& _op, eoDistance<eoReal<eoMinimizingFitness> >* _dist = NULL);
// run // run
void run_ea(eoAlgo<eoReal<double> >& _ga, eoPop<eoReal<double> >& _pop); void run_ea(eoAlgo<eoReal<double> >& _ga, eoPop<eoReal<double> >& _pop);

8
eo/src/ga/make_algo_scalar_ga.cpp
View file

@ -52,13 +52,13 @@
// Algo // Algo
/////// ///////
eoAlgo<eoBit<double> >& make_algo_scalar(eoParser& _parser, eoState& _state, eoEvalFunc<eoBit<double> >& _eval, eoContinue<eoBit<double> >& _continue, eoGenOp<eoBit<double> >& _op) eoAlgo<eoBit<double> >& make_algo_scalar(eoParser& _parser, eoState& _state, eoEvalFunc<eoBit<double> >& _eval, eoContinue<eoBit<double> >& _continue, eoGenOp<eoBit<double> >& _op, eoDistance<eoBit<double> >* _dist)
{ {
return do_make_algo_scalar(_parser, _state, _eval, _continue, _op); return do_make_algo_scalar(_parser, _state, _eval, _continue, _op, _dist);
} }
eoAlgo<eoBit<eoMinimizingFitness> >& make_algo_scalar(eoParser& _parser, eoState& _state, eoEvalFunc<eoBit<eoMinimizingFitness> >& _eval, eoContinue<eoBit<eoMinimizingFitness> >& _continue, eoGenOp<eoBit<eoMinimizingFitness> >& _op) eoAlgo<eoBit<eoMinimizingFitness> >& make_algo_scalar(eoParser& _parser, eoState& _state, eoEvalFunc<eoBit<eoMinimizingFitness> >& _eval, eoContinue<eoBit<eoMinimizingFitness> >& _continue, eoGenOp<eoBit<eoMinimizingFitness> >& _op, eoDistance<eoBit<eoMinimizingFitness> >* _dist)
{ {
return do_make_algo_scalar(_parser, _state, _eval, _continue, _op); return do_make_algo_scalar(_parser, _state, _eval, _continue, _op, _dist);
} }

5
eo/src/ga/make_ga.h
View file

@ -45,6 +45,7 @@
#include <utils/eoCheckPoint.h> #include <utils/eoCheckPoint.h>
#include <eoGenOp.h> #include <eoGenOp.h>
#include <eoPop.h> #include <eoPop.h>
#include <utils/eoDistance.h>
#include <ga/eoBit.h> #include <ga/eoBit.h>
@ -77,9 +78,9 @@ eoCheckPoint<eoBit<eoMinimizingFitness> >& make_checkpoint(eoParser& _parser, eo
// the algo // the algo
eoAlgo<eoBit<double> >& make_algo_scalar(eoParser& _parser, eoState& _state, eoEvalFunc<eoBit<double> >& _eval, eoContinue<eoBit<double> >& _ccontinue, eoGenOp<eoBit<double> >& _op); eoAlgo<eoBit<double> >& make_algo_scalar(eoParser& _parser, eoState& _state, eoEvalFunc<eoBit<double> >& _eval, eoContinue<eoBit<double> >& _ccontinue, eoGenOp<eoBit<double> >& _op, eoDistance<eoBit<double> >* _dist = NULL);
eoAlgo<eoBit<eoMinimizingFitness> >& make_algo_scalar(eoParser& _parser, eoState& _state, eoEvalFunc<eoBit<eoMinimizingFitness> >& _eval, eoContinue<eoBit<eoMinimizingFitness> >& _ccontinue, eoGenOp<eoBit<eoMinimizingFitness> >& _op); eoAlgo<eoBit<eoMinimizingFitness> >& make_algo_scalar(eoParser& _parser, eoState& _state, eoEvalFunc<eoBit<eoMinimizingFitness> >& _eval, eoContinue<eoBit<eoMinimizingFitness> >& _ccontinue, eoGenOp<eoBit<eoMinimizingFitness> >& _op, eoDistance<eoBit<eoMinimizingFitness> >* _dist = NULL);
// run // run
void run_ea(eoAlgo<eoBit<double> >& _ga, eoPop<eoBit<double> >& _pop); void run_ea(eoAlgo<eoBit<double> >& _ga, eoPop<eoBit<double> >& _pop);

43
eo/src/utils/eoDistance.h
View file

@ -27,7 +27,6 @@
#define _eoDistance_H #define _eoDistance_H
#include <eoFunctor.h> #include <eoFunctor.h>
/** /**
This is a generic class for distance functors: This is a generic class for distance functors:
takes 2 things ane returns a double takes 2 things ane returns a double
@ -36,27 +35,63 @@ template< class EOT >
class eoDistance : public eoBF<const EOT &, const EOT &, double> class eoDistance : public eoBF<const EOT &, const EOT &, double>
{}; {};
/** /**
This is a generic class for Euclidain distance computation: This is a generic class for Euclidain distance (L2 norm) computation:
assumes the 2 things are std::vectors of something that is double-castable assumes the 2 things are std::vectors of something that is double-castable
*/ */
template< class EOT > template< class EOT >
class eoQuadDistance : public eoDistance<EOT> class eoQuadDistance : public eoDistance<EOT>
{ {
public: public:
double operator()(const EOT & _v1, const EOT & _v2) double operator()(const EOT & _v1, const EOT & _v2)
{ {
double sum=0.0; double sum=0.0;
for (unsigned i=0; i<_v1.size(); i++) for (unsigned i=0; i<_v1.size(); i++)
{ {
double r = static_cast<double> (_v1[i]) - static_cast<double> (_v2[i]); double r = static_cast<double> (_v1[i]) - static_cast<double> (_v2[i]);
sum += r*r; sum += r*r;
} }
return sqrt(sum);
}
};
/**
This is a generic class for L1 distance computation:
assumes the 2 things are std::vectors of something
that is double-castable
For bitstrings, this is the Hamming distance
*/
template< class EOT >
class eoHammingDistance : public eoDistance<EOT>
{
public:
double operator()(const EOT & _v1, const EOT & _v2)
{
double sum=0.0;
for (unsigned i=0; i<_v1.size(); i++)
{
double r = static_cast<double> (_v1[i]) - static_cast<double> (_v2[i]);
sum += fabs(r);
}
return sum; return sum;
} }
}; };
/* this distance measures the difference in fitness
* I am not sure it can be of any use, though ...
* except for some testing
*/
template< class EOT >
class eoFitnessDistance : public eoDistance<EOT>
{
public:
double operator()(const EOT & _v1, const EOT & _v2)
{
double d = _v1.fitness() - _v2.fitness();
return sqrt(d*d);
}
};

9
eo/test/Makefile.am
View file

@ -17,7 +17,7 @@ CXXFLAGS = -g -Wall
# PLEASE don't break the line (see create_batch.sh) # PLEASE don't break the line (see create_batch.sh)
check_PROGRAMS = t-eoParetoFitness t-eoPareto t-eofitness t-eoRandom t-eobin t-eoVirus t-MGE t-MGE1bit t-MGE-control t-eoStateAndParser t-eoCheckpointing t-eoSSGA t-eoExternalEO t-eoSymreg t-eo t-eoReplacement t-eoSelect t-eoGenOp t-eoGA t-eoReal t-eoVector t-eoESAll t-eoPBIL t-eoFitnessAssembled t-eoFitnessAssembledEA t-eoRoulette check_PROGRAMS = t-eoParetoFitness t-eoPareto t-eofitness t-eoRandom t-eobin t-eoVirus t-MGE t-MGE1bit t-MGE-control t-eoStateAndParser t-eoCheckpointing t-eoSSGA t-eoExternalEO t-eoSymreg t-eo t-eoReplacement t-eoSelect t-eoGenOp t-eoGA t-eoReal t-eoVector t-eoESAll t-eoPBIL t-eoFitnessAssembled t-eoFitnessAssembledEA t-eoRoulette t-eoSharing
#The run_tests script can be used to check various arguments #The run_tests script can be used to check various arguments
TESTS=$(check_PROGRAMS) run_tests TESTS=$(check_PROGRAMS) run_tests
@ -198,3 +198,10 @@ t_eoRoulette_LDFLAGS = -lm
t_eoRoulette_LDADD = $(LDADDS) t_eoRoulette_LDADD = $(LDADDS)
############################################################################### ###############################################################################
t_eoSharing_SOURCES = t-eoSharing.cpp
t_eoSharing_DEPENDENCIES = $(DEPS)
t_eoSharing_LDFLAGS = -lm
t_eoSharing_LDADD = $(LDADDS)
###############################################################################

10
eo/tutorial/Lesson4/BitEA.cpp
View file

@ -10,7 +10,7 @@
using namespace std; using namespace std;
int main(int argc, char* argv[]) int main(int argc, char* argv[])
{ {
try try
{ {
@ -30,13 +30,17 @@ int main(int argc, char* argv[])
// EVAL // EVAL
// The evaluation fn - encapsulated into an eval counter for output // The evaluation fn - encapsulated into an eval counter for output
eoEvalFuncPtr<EOT, float> mainEval( binary_value<EOT> ); eoEvalFuncPtr<EOT, double> mainEval( binary_value<EOT> );
eoEvalFuncCounter<EOT> eval(mainEval); eoEvalFuncCounter<EOT> eval(mainEval);
// REPRESENTATION // REPRESENTATION
// the genotype - through a genotype initializer // the genotype - through a genotype initializer
eoInit<EOT>& init = make_genotype(parser, state, EOT()); eoInit<EOT>& init = make_genotype(parser, state, EOT());
// if you want to do sharing, you'll need a distance.
// here Hamming distance
eoHammingDistance<EOT> dist;
// OPERATORS // OPERATORS
// Build the variation operator (any seq/prop construct) // Build the variation operator (any seq/prop construct)
eoGenOp<EOT>& op = make_op(parser, state, init); eoGenOp<EOT>& op = make_op(parser, state, init);
@ -56,7 +60,7 @@ int main(int argc, char* argv[])
eoCheckPoint<EOT> & checkpoint = make_checkpoint(parser, state, eval, term); eoCheckPoint<EOT> & checkpoint = make_checkpoint(parser, state, eval, term);
// GENERATION // GENERATION
// algorithm (need the operator!) // algorithm (need the operator!)
eoAlgo<EOT>& ga = make_algo_scalar(parser, state, eval, checkpoint, op); eoAlgo<EOT>& ga = make_algo_scalar(parser, state, eval, checkpoint, op, &dist);
///// End of construction of the algorith ///// End of construction of the algorith
///////////////////////////////////////// /////////////////////////////////////////

4
eo/tutorial/Lesson4/binary_value.h
View file

@ -7,9 +7,9 @@
@param _chrom A binary chromosome @param _chrom A binary chromosome
*/ */
template <class Chrom> float binary_value(const Chrom& _chrom) template <class Chrom> double binary_value(const Chrom& _chrom)
{ {
float sum = 0; double sum = 0;
for (unsigned i = 0; i < _chrom.size(); i++) for (unsigned i = 0; i < _chrom.size(); i++)
if (_chrom[i]) if (_chrom[i])
sum += _chrom[i]; sum += _chrom[i];