231 lines
7 KiB
C++
231 lines
7 KiB
C++
/** -*- mode: c++; c-indent-level: 4; c++-member-init-indent: 8; comment-column: 35; -*-
|
|
|
|
-----------------------------------------------------------------------------
|
|
eoSelectFromWorth.h
|
|
(c) Maarten Keijzer, 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
|
|
mkeijzer@dhi.dk
|
|
*/
|
|
//-----------------------------------------------------------------------------
|
|
|
|
#ifndef _eoSelectFromWorth_h
|
|
#define _eoSelectFromWorth_h
|
|
|
|
#include <iostream>
|
|
//-----------------------------------------------------------------------------
|
|
#include <eoSelectOne.h>
|
|
#include <eoPerf2Worth.h>
|
|
#include <utils/selectors.h>
|
|
//-----------------------------------------------------------------------------
|
|
|
|
/** selects one element from a population (is an eoSelectOne)
|
|
but the selection is based on a std::vector of Worth that is different
|
|
from the fitnesses (e.g. EO fitness is what Koza terms "raw fitness",
|
|
Worth is what the selection is based upon).
|
|
|
|
see class eoPerf2Worth: an eoStat that transforms fitnesses into Worthes
|
|
|
|
Note: Worthes will not always be doubles - see some multi-objective
|
|
techniques where it is a std::pair of doubles ...
|
|
|
|
It has to have a < operator it you want to call an existing
|
|
selector (see selector.h) - but of course you can write the whole
|
|
thing ...
|
|
|
|
@ingroup Selectors
|
|
*/
|
|
template <class EOT, class WorthType = double>
|
|
class eoSelectFromWorth : public eoSelectOne<EOT>
|
|
{
|
|
public:
|
|
|
|
/* Default ctor from an eoPerf2Worth object */
|
|
eoSelectFromWorth(eoPerf2Worth<EOT, WorthType>& _perf2Worth)
|
|
: perf2Worth(_perf2Worth)
|
|
{}
|
|
|
|
/* setup the worthes */
|
|
virtual void setup(const eoPop<EOT>& pop) {
|
|
perf2Worth(pop);
|
|
#ifndef NDEBUG
|
|
fitness.resize(pop.size());
|
|
for (unsigned i = 0; i < pop.size(); ++i) {
|
|
fitness[i] = pop[i].fitness();
|
|
}
|
|
#endif
|
|
}
|
|
|
|
|
|
protected:
|
|
|
|
eoPerf2Worth<EOT, WorthType>& perf2Worth;
|
|
|
|
#ifndef NDEBUG
|
|
std::vector<typename EOT::Fitness> fitness;
|
|
void check_sync(unsigned index, const EOT& _eo) {
|
|
if (fitness[index] != _eo.fitness()) {
|
|
throw std::runtime_error("eoSelectFromWorth: fitnesses are not in sync");
|
|
}
|
|
}
|
|
#endif
|
|
};
|
|
|
|
|
|
/** An instance of eoSelectPerf2Worth that does selection from the Worthes
|
|
* using a ... determinisitic tournament, yes!
|
|
|
|
@ingroup Selectors
|
|
*/
|
|
template <class EOT, class WorthT = double>
|
|
class eoDetTournamentWorthSelect : public eoSelectFromWorth<EOT, WorthT>
|
|
{
|
|
public:
|
|
|
|
using eoSelectFromWorth<EOT, WorthT>::perf2Worth;
|
|
|
|
typedef typename std::vector<WorthT>::iterator worthIterator;
|
|
|
|
/* Default ctor from an eoPerf2Worth object + tournament size */
|
|
eoDetTournamentWorthSelect(eoPerf2Worth<EOT, WorthT>& perf2Worth,
|
|
unsigned _tSize)
|
|
: eoSelectFromWorth<EOT, WorthT>(perf2Worth), tSize(_tSize) {}
|
|
|
|
/* Perform deterministic tournament on worthes by calling the
|
|
appropriate fn see selectors.h */
|
|
virtual const EOT& operator()(const eoPop<EOT>& pop) {
|
|
worthIterator it = deterministic_tournament(perf2Worth.value().begin(),
|
|
perf2Worth.value().end(),
|
|
tSize);
|
|
unsigned index = it - perf2Worth.value().begin();
|
|
#ifndef NDEBUG
|
|
// check whether the stuff is still in sync
|
|
check_sync(index, pop[index]);
|
|
#endif
|
|
return pop[index];
|
|
}
|
|
|
|
|
|
private:
|
|
|
|
unsigned tSize;
|
|
};
|
|
|
|
/** An instance of eoSelectPerf2Worth that does selection from the Worthes
|
|
* using a ... stochastic tournament, yes!
|
|
|
|
@ingroup Selectors
|
|
*/
|
|
template <class EOT, class WorthT = double>
|
|
class eoStochTournamentWorthSelect : public eoSelectFromWorth<EOT, WorthT>
|
|
{
|
|
public:
|
|
|
|
using eoSelectFromWorth<EOT, WorthT>::perf2Worth;
|
|
|
|
typedef typename std::vector<WorthT>::iterator worthIterator;
|
|
|
|
/* Default ctor from an eoPerf2Worth object + tournament rate */
|
|
eoStochTournamentWorthSelect(eoPerf2Worth<EOT, WorthT> &_perf2Worth, double _tRate)
|
|
: eoSelectFromWorth<EOT, WorthT>(_perf2Worth), tRate(_tRate)
|
|
{}
|
|
|
|
/* Perform stochastic tournament on worthes
|
|
by calling the appropriate fn in selectors.h
|
|
*/
|
|
virtual const EOT& operator()(const eoPop<EOT>& _pop) {
|
|
worthIterator it = stochastic_tournament(perf2Worth.value().begin(),
|
|
perf2Worth.value().end(),
|
|
tRate);
|
|
|
|
unsigned index = it - perf2Worth.value().begin();
|
|
|
|
#ifndef NDEBUG
|
|
// check whether the stuff is still in sync
|
|
check_sync(index, _pop[index]);
|
|
#endif
|
|
|
|
return _pop[index];
|
|
}
|
|
|
|
private:
|
|
double tRate;
|
|
};
|
|
|
|
/** An instance of eoSelectPerf2Worth that does selection from the Worthes
|
|
* using a ... roulette wheel selection, yes!
|
|
|
|
@ingroup Selectors
|
|
*/
|
|
template <class EOT, class WorthT = double>
|
|
class eoRouletteWorthSelect : public eoSelectFromWorth<EOT, WorthT>
|
|
{
|
|
public:
|
|
|
|
using eoSelectFromWorth<EOT, WorthT>::perf2Worth;
|
|
|
|
typedef typename std::vector<WorthT>::iterator worthIterator;
|
|
|
|
|
|
/* Default ctor from an eoPerf2Worth object */
|
|
eoRouletteWorthSelect(eoPerf2Worth<EOT, WorthT> &_perf2Worth)
|
|
: eoSelectFromWorth<EOT, WorthT>(_perf2Worth)
|
|
{}
|
|
|
|
/* We have to override the default behavior to compute the total
|
|
* only once!
|
|
*/
|
|
virtual void setup(const eoPop<EOT>& _pop)
|
|
{
|
|
eoSelectFromWorth<EOT, WorthT>::setup(_pop);
|
|
total = 0.0;
|
|
for (worthIterator it = perf2Worth.value().begin();
|
|
it<perf2Worth.value().end(); ++it)
|
|
total += (*it);
|
|
}
|
|
|
|
/* Perform roulette wheel on worthes
|
|
by calling the appropriate fn
|
|
see selectors.h
|
|
*/
|
|
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(perf2Worth.value().begin(),
|
|
perf2Worth.value().end(),
|
|
total);
|
|
|
|
unsigned index = it - perf2Worth.value().begin();
|
|
|
|
#ifndef NDEBUG
|
|
// check whether the stuff is still in sync
|
|
this->check_sync(index, _pop[index]);
|
|
#endif
|
|
|
|
return _pop[index];
|
|
return _pop[it - perf2Worth.value().begin()];
|
|
}
|
|
|
|
private:
|
|
double total;
|
|
};
|
|
|
|
#endif
|