139 lines
5 KiB
C++
139 lines
5 KiB
C++
/** -*- mode: c++; c-indent-level: 4; c++-member-init-indent: 8; comment-column: 35; -*-
|
|
|
|
-----------------------------------------------------------------------------
|
|
eoRankingCached.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: todos@geneura.ugr.es, http://geneura.ugr.es
|
|
Marc.Schoenauer@polytechnique.fr
|
|
mkeijzer@dhi.dk
|
|
*/
|
|
//-----------------------------------------------------------------------------
|
|
|
|
#ifndef eoRankingCached_h
|
|
#define eoRankingCached_h
|
|
|
|
#include "eoPerf2Worth.h"
|
|
|
|
/**
|
|
* @class eoRankingCached
|
|
* @brief Cached version of eoRanking that stores precomputed values for better performance
|
|
*
|
|
* This class implements the same ranking algorithm as eoRanking but adds a caching layer
|
|
* that stores frequently used values when the population size remains constant between
|
|
* calls. This optimization is particularly useful in steady-state evolution where the
|
|
* population size typically doesn't change between selection operations.
|
|
*
|
|
* The caching mechanism stores:
|
|
* - Population size related values (pSize, pSizeMinusOne)
|
|
* - Precomputed coefficients (alpha, beta, gamma)
|
|
*
|
|
* @warning This optimization should only be used when the population size remains constant
|
|
* between calls to the operator. For dynamic population sizes, use the standard eoRanking.
|
|
*
|
|
* @ingroup Selectors
|
|
*/
|
|
template <class EOT>
|
|
class eoRankingCached : public eoPerf2Worth<EOT>
|
|
{
|
|
public:
|
|
using eoPerf2Worth<EOT>::value;
|
|
|
|
/* Ctor:
|
|
@param _p selective pressure (in (1,2]
|
|
@param _e exponent (1 == linear)
|
|
*/
|
|
eoRankingCached(double _p = 2.0, double _e = 1.0) : pressure(_p), exponent(_e), cached_pSize(0)
|
|
{
|
|
assert(1 < pressure and pressure <= 2);
|
|
}
|
|
|
|
/*
|
|
Computes the ranked fitness with caching optimization
|
|
Fitnesses range in [m,M] where:
|
|
- m = 2-pressure/popSize
|
|
- M = pressure/popSize
|
|
The progression between m and M depends on the exponent (linear when exponent=1)
|
|
|
|
@param _pop The population to rank
|
|
*/
|
|
virtual void operator()(const eoPop<EOT> &_pop)
|
|
{
|
|
unsigned pSize = _pop.size();
|
|
|
|
if (pSize <= 1)
|
|
throw eoPopSizeException(pSize, "cannot do ranking with population of size <= 1");
|
|
|
|
// value() refers to the std::vector of worthes (we're in an eoParamvalue)
|
|
value().resize(pSize);
|
|
|
|
// Cache population-size dependent values only when population size changes
|
|
if (pSize != cached_pSize)
|
|
{
|
|
cached_pSize = pSize;
|
|
cached_pSizeMinusOne = pSize - 1;
|
|
cached_beta = (2 - pressure) / pSize;
|
|
cached_gamma = (2 * pressure - 2) / pSize;
|
|
cached_alpha = (2 * pressure - 2) / (pSize * cached_pSizeMinusOne);
|
|
}
|
|
|
|
std::vector<const EOT *> rank;
|
|
_pop.sort(rank);
|
|
|
|
// map of indices for the population
|
|
std::unordered_map<const EOT *, unsigned> indexMap;
|
|
for (unsigned i = 0; i < pSize; ++i)
|
|
{
|
|
indexMap[&_pop[i]] = i;
|
|
}
|
|
|
|
if (exponent == 1.0) // no need for exponential then (linear case)
|
|
{
|
|
for (unsigned i = 0; i < pSize; i++)
|
|
{
|
|
const EOT *indiv = rank[i];
|
|
int which = indexMap[indiv];
|
|
value()[which] = cached_alpha * (pSize - i) + cached_beta;
|
|
}
|
|
}
|
|
else // non-linear case (exponent != 1)
|
|
{
|
|
for (unsigned i = 0; i < pSize; i++)
|
|
{
|
|
const EOT *indiv = rank[i];
|
|
int which = indexMap[indiv];
|
|
// value is in [0,1]
|
|
double tmp = ((double)(pSize - i)) / pSize;
|
|
// to the exponent, and back to [m,M]
|
|
value()[which] = cached_gamma * pow(tmp, exponent) + cached_beta;
|
|
}
|
|
}
|
|
}
|
|
|
|
private:
|
|
double pressure; // selective pressure (1 < pressure <= 2)
|
|
double exponent; // exponent (1 = linear)
|
|
|
|
// Cached values (recomputed only when population size changes)
|
|
unsigned cached_pSize; // last seen population size
|
|
unsigned cached_pSizeMinusOne; // pSize - 1
|
|
double cached_alpha; // linear scaling coefficient
|
|
double cached_beta; // base value coefficient
|
|
double cached_gamma; // non-linear scaling coefficient
|
|
};
|
|
|
|
#endif
|