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

intermediate commit 3

Browse source
This commit is contained in:
LPTK 2013-06-25 14:14:37 +02:00
commit eeb9faec4a
4 changed files with 419 additions and 606 deletions
Download patch file Download diff file Expand all files Collapse all files

148
mo/src/algo/moLocalSearch.h
View file

@ -47,99 +47,97 @@
template<class Neighbor>
class moLocalSearch: public eoMonOp<typename Neighbor::EOT> {
public:
typedef moNeighborhood<Neighbor> Neighborhood;
typedef moNeighborhoodExplorer<Neighbor> NeighborhoodExplorer;
typedef typename Neighbor::EOT EOT;
typedef moNeighborhood<Neighbor> Neighborhood;
typedef moNeighborhoodExplorer<Neighbor> NeighborhoodExplorer;
typedef typename Neighbor::EOT EOT;
/**
* Constructor of a moLocalSearch
* @param _searchExpl a neighborhood explorer
* @param _cont an external continuator (can be a checkpoint!)
* @param _fullEval a full evaluation function
*/
moLocalSearch(NeighborhoodExplorer& _searchExpl,
moContinuator<Neighbor> & _cont, eoEvalFunc<EOT>& _fullEval) :
searchExplorer(_searchExpl), cont(&_cont), fullEval(_fullEval) {
}
;
/**
* Constructor of a moLocalSearch
* @param _searchExpl a neighborhood explorer
* @param _cont an external continuator (can be a checkpoint!)
* @param _fullEval a full evaluation function
*/
moLocalSearch(NeighborhoodExplorer& _searchExpl,
moContinuator<Neighbor> & _cont, eoEvalFunc<EOT>& _fullEval)
: searchExplorer(_searchExpl), cont(&_cont), fullEval(_fullEval)
{ }
/**
* Run the local search on a solution
* @param _solution the related solution
*/
virtual bool operator()(EOT & _solution) {
/**
* Run the local search on a solution
* @param _solution the related solution
*/
virtual bool operator()(EOT & _solution) {
if (_solution.invalid())
fullEval(_solution);
if (_solution.invalid())
fullEval(_solution);
// initialization of the parameter of the search (for example fill empty the tabu list)
searchExplorer.initParam(_solution);
// initialization of the parameter of the search (for example fill empty the tabu list)
searchExplorer.initParam(_solution);
// initialization of the external continuator (for example the time, or the number of generations)
cont->init(_solution);
// initialization of the external continuator (for example the time, or the number of generations)
cont->init(_solution);
bool b;
do {
// explore the neighborhood of the solution
searchExplorer(_solution);
// if a solution in the neighborhood can be accepted
if (searchExplorer.accept(_solution)) {
searchExplorer.move(_solution);
searchExplorer.moveApplied(true);
} else
searchExplorer.moveApplied(false);
bool b;
do {
// explore the neighborhood of the solution
searchExplorer(_solution);
// if a solution in the neighborhood can be accepted
if (searchExplorer.accept(_solution)) {
searchExplorer.move(_solution);
searchExplorer.moveApplied(true);
} else
searchExplorer.moveApplied(false);
// update the parameter of the search (for ex. Temperature of the SA)
searchExplorer.updateParam(_solution);
// update the parameter of the search (for ex. Temperature of the SA)
searchExplorer.updateParam(_solution);
b = (*cont)(_solution);
} while (b && searchExplorer.isContinue(_solution));
b = (*cont)(_solution);
} while (b && searchExplorer.isContinue(_solution));
searchExplorer.terminate(_solution);
searchExplorer.terminate(_solution);
cont->lastCall(_solution);
cont->lastCall(_solution);
return true;
}
;
return true;
}
/**
* Set an external continuator
* @param _cont the external continuator
*/
void setContinuator(moContinuator<Neighbor> & _cont) {
cont = &_cont;
}
/**
* Set an external continuator
* @param _cont the external continuator
*/
void setContinuator(moContinuator<Neighbor> & _cont) {
cont = &_cont;
}
/**
* external continuator object
*
* @overload
* @return the external continuator
*/
moContinuator<Neighbor>* getContinuator() const {
return cont;
}
/**
* external continuator object
*
* @overload
* @return the external continuator
*/
moContinuator<Neighbor>* getContinuator() const {
return cont;
}
/**
* to get the neighborhood explorer
*
* @overload
* @return the neighborhood explorer
*/
moNeighborhoodExplorer<Neighbor> & getNeighborhoodExplorer() const {
return searchExplorer;
}
/**
* to get the neighborhood explorer
*
* @overload
* @return the neighborhood explorer
*/
moNeighborhoodExplorer<Neighbor> & getNeighborhoodExplorer() const {
return searchExplorer;
}
protected:
// make the exploration of the neighborhood according to a local search heuristic
moNeighborhoodExplorer<Neighbor>& searchExplorer;
// make the exploration of the neighborhood according to a local search heuristic
moNeighborhoodExplorer<Neighbor>& searchExplorer;
// external continuator
moContinuator<Neighbor> * cont;
// external continuator
moContinuator<Neighbor> * cont;
//full evaluation function
eoEvalFunc<EOT>& fullEval;
//full evaluation function
eoEvalFunc<EOT>& fullEval;
};
#endif

58
mo/src/algo/moSA.h
View file

@ -67,9 +67,13 @@ public:
moLocalSearch<Neighbor>(explorer, trueCont, _fullEval)
{ }*/
moSA(Neighborhood& _neighborhood, eoEvalFunc<EOT>& _fullEval, moEval<Neighbor>& _eval, double _initT=10, double _alpha=0.9, unsigned _span=100, double _finalT=0.01)
: moLocalSearch<Neighbor>(explorer = *(defaultExplorer = new moSAexplorer<Neighbor>(_neighborhood, _eval, *defaultSolNeighborComp, *defaultCool)), *(trueCont = new moTrueContinuator<Neighbor>()), _fullEval),
defaultCool(new moSimpleCoolingSchedule<EOT>(_initT, _alpha, _span, _finalT))
//default_eval(NULL), // removed in C++11 with unique_ptr
: moLocalSearch<Neighbor> (
explorer_ptr = defaultExplorer = new moSAexplorer<Neighbor>(_neighborhood, _eval, NULL, *(defaultCool = new moSimpleCoolingSchedule<EOT>(_initT, _alpha, _span, _finalT))),
*(trueCont = new moTrueContinuator<Neighbor>()),
_fullEval ),
explorer(*explorer_ptr),
//defaultCool(),
default_eval(NULL) // removed in C++11 with unique_ptr
//defaultSolNeighborComp(new moSolNeighborComparator<Neighbor>())
//explorer(_neighborhood, _eval, *defaultSolNeighborComp, *defaultCool)
{ }
@ -146,46 +150,76 @@ public:
_cool )
{ }*/
: moLocalSearch<Neighbor> (
explorer = *(defaultExplorer = new moSAexplorer<Neighbor> (
explorer_ptr = defaultExplorer = new moSAexplorer<Neighbor> (
_neighborhood,
_eval, //_eval.hasValue()? _eval.get(): *(default_eval = new moFullEvalByCopy<Neighbor>(_fullEval)),
//_eval, //_eval.hasValue()? _eval.get(): *(default_eval = new moFullEvalByCopy<Neighbor>(_fullEval)),
_eval.hasValue()? default_eval = NULL, _eval.get(): *(default_eval = new moFullEvalByCopy<Neighbor>(_fullEval)),
// C++11: _eval.hasValue()? _eval.get(): default_eval = new moFullEvalByCopy<Neighbor>(),
_comp, //_comp.hasValue()? _comp.get(): *(defaultSolNeighborComp = new moSolNeighborComparator<Neighbor>()),
_cool )),
_cont.hasValue()? _cont.get(): *(trueCont = new moTrueContinuator<Neighbor>()),
_cool ),
_cont.hasValue()? trueCont = NULL, _cont.get(): *(trueCont = new moTrueContinuator<Neighbor>()),
_fullEval ),
explorer(*explorer_ptr),
defaultCool(NULL) // removed in C++11 with unique_ptr
//default_eval(NULL), // removed in C++11 with unique_ptr
//trueCont(NULL) // removed in C++11 with unique_ptr
//defaultSolNeighborComp(NULL) // removed in C++11 with unique_ptr
{ }
moSA (
eoEvalFunc<EOT>& _fullEval,
moSAexplorer<Neighbor>& _explorer,
eoOptional< moContinuator<Neighbor> > _cont = NULL
)
: moLocalSearch<Neighbor> (
*(explorer_ptr = &_explorer),
_cont.hasValue()? _cont.get(): *(trueCont = new moTrueContinuator<Neighbor>()), _fullEval ),
defaultExplorer(NULL), // removed in C++11 with unique_ptr
explorer(*explorer_ptr),
defaultCool(NULL), // removed in C++11 with unique_ptr
//default_eval(NULL), // removed in C++11 with unique_ptr
trueCont(NULL) // removed in C++11 with unique_ptr
//defaultSolNeighborComp(NULL) // removed in C++11 with unique_ptr
{ }
/*
moSA (
eoEvalFunc<EOT>& _fullEval,
moSAexplorer<Neighbor>& _explorer,
eoOptional< moContinuator<Neighbor> > _cont = NULL
moContinuator<Neighbor> _cont
)
: moLocalSearch<Neighbor> (
*(explorer = &_explorer),
_cont.hasValue()? _cont.get(): *(trueCont = new moTrueContinuator<Neighbor>()), _fullEval ),
_cont, _fullEval ),
defaultExplorer(NULL), // removed in C++11 with unique_ptr
defaultCool(NULL), // removed in C++11 with unique_ptr
//default_eval(NULL), // removed in C++11 with unique_ptr
trueCont(NULL) // removed in C++11 with unique_ptr
//defaultSolNeighborComp(NULL) // removed in C++11 with unique_ptr
{ }
*/
virtual ~moSA ()
{
// Note: using unique_ptr would allow us to remove this explicit destructor, but they were only introduced in C++11
if (trueCont != NULL)
delete trueCont;
if (explorer != NULL)
delete explorer;
if (defaultExplorer != NULL)
delete defaultExplorer;
if (default_eval != NULL)
delete default_eval;
}
private:
moFullEvalByCopy<Neighbor>* default_eval;
moSAexplorer<Neighbor>* defaultExplorer;
moSAexplorer<Neighbor>& explorer; // Not NULL (ref)
moSAexplorer<Neighbor>* explorer_ptr; // Not NULL
moSAexplorer<Neighbor>& explorer;
moSimpleCoolingSchedule<EOT>* defaultCool; // C++11: const std::unique_ptr<moSimpleCoolingSchedule<EOT>>
//moFullEvalByCopy<Neighbor>* default_eval;
moTrueContinuator<Neighbor>* trueCont;

571
mo/src/coolingSchedule/moTrikiCoolingSchedule.h
View file

@ -55,297 +55,298 @@ template< class EOT, class Neighbor > //, class Neighborhood >
class moTrikiCoolingSchedule: public moCoolingSchedule< EOT >
{
public:
//typedef typename Neighbor::EOT EOT ;
typedef moNeighborhood<Neighbor> Neighborhood ;
//typedef typename Neighbor::EOT EOT ;
typedef moNeighborhood<Neighbor> Neighborhood ;
//! Constructor
/*!
*/
//! Constructor
/*!
*/
moTrikiCoolingSchedule (Neighborhood& _neighborhood, moEval<Neighbor>& _eval, double _initTemp)
: initTemp(_initTemp),
mu2(10), // mu2 typically belongs to [1; 20]
K1(2), // K1 in [1; 4], the number of chains without reaching equilibrium before we raise the temperature
K2(5), // ???
lambda1(2), // the increase in temperature, typically in [1.5; 4]
lambda2(.7), // lambda2 in [0.5; 0.99]
mu1(10), // target decrease in cost factor, in [2; 20]
xi(1.05), // xi typically belongs to [1; 1.1]
max_accepted(50), // depends on pb/neighborhood
max_generated(100), // depends on pb/neighborhood
theta(10), // theta is typically set to 10
statIsInitialized(false),
outf("out.data")
{ }
moTrikiCoolingSchedule (
Neighborhood& _neighborhood, moEval<Neighbor>& _eval, double _initTemp,
double _max_accepted,
double _max_generated
)
: initTemp(_initTemp),
mu2(10), // mu2 typically belongs to [1; 20]
K1(2), // K1 in [1; 4], the number of chains without reaching equilibrium before we raise the temperature
K2(5), // ???
lambda1(2), // the increase in temperature, typically in [1.5; 4]
lambda2(.7), // lambda2 in [0.5; 0.99]
mu1(10), // target decrease in cost factor, in [2; 20]
xi(1.05), // xi typically belongs to [1; 1.1]
max_accepted(_max_accepted), // depends on pb/neighborhood
max_generated(_max_generated), // depends on pb/neighborhood
theta(10), // theta is typically set to 10
statIsInitialized(false),
outf("out.data")
{ }
/**
* Initial temperature
* @param _solution initial solution
*/
double init(EOT & _solution) {
accepted = generated = costs_sum = 0;
negative_temp = equilibrium_not_reached = frozen = 0;
reinitializing = false;
terminated = false;
statIsInitialized = false;
///
cout << "INIT T=" << initTemp << endl;
///
//outf.open("out");
//outf << "ok";
//outf.close();
return initTemp;
}
moTrikiCoolingSchedule (Neighborhood& _neighborhood, moEval<Neighbor>& _eval, double _initTemp)
: initTemp(_initTemp),
mu2(10), // mu2 typically belongs to [1; 20]
K1(2), // K1 in [1; 4], the number of chains without reaching equilibrium before we raise the temperature
K2(5), // ???
lambda1(2), // the increase in temperature, typically in [1.5; 4]
lambda2(.7), // lambda2 in [0.5; 0.99]
mu1(10), // target decrease in cost factor, in [2; 20]
xi(1.05), // xi typically belongs to [1; 1.1]
max_accepted(50), // depends on pb/neighborhood
max_generated(100), // depends on pb/neighborhood
theta(10), // theta is typically set to 10
statIsInitialized(false),
outf("out.data")
{ }
moTrikiCoolingSchedule (
Neighborhood& _neighborhood, moEval<Neighbor>& _eval, double _initTemp,
double _max_accepted,
double _max_generated
)
: initTemp(_initTemp),
mu2(10), // mu2 typically belongs to [1; 20]
K1(2), // K1 in [1; 4], the number of chains without reaching equilibrium before we raise the temperature
K2(5), // ???
lambda1(2), // the increase in temperature, typically in [1.5; 4]
lambda2(.7), // lambda2 in [0.5; 0.99]
mu1(10), // target decrease in cost factor, in [2; 20]
xi(1.05), // xi typically belongs to [1; 1.1]
max_accepted(_max_accepted), // depends on pb/neighborhood
max_generated(_max_generated), // depends on pb/neighborhood
theta(10), // theta is typically set to 10
statIsInitialized(false),
outf("out.data")
{ }
/**
* Initial temperature
* @param _solution initial solution
*/
double init(EOT & _solution) {
accepted = generated = costs_sum = 0;
negative_temp = equilibrium_not_reached = frozen = 0;
reinitializing = false;
terminated = false;
statIsInitialized = false;
///
cout << "INIT T=" << initTemp << endl;
///
//outf.open("out");
//outf << "ok";
//outf.close();
return initTemp;
}
/**
* update the temperature by a factor
* @param _temp current temperature to update
* @param _acceptedMove true when the move is accepted, false otherwise
*/
void update(double& _temp, bool _acceptedMove, EOT & _solution) {
//cout << _temp << " g " << generated << endl;
generated++;
if (_acceptedMove)
{
accepted++;
//costs_sum += _solution.fitness();
//varStat(_solution);
if (statIsInitialized)
momentStat(_solution);
else momentStat.init(_solution), statIsInitialized = true;
//cout << _solution.fitness() << " avgCost=" << momentStat.value().first << endl;
}
if (accepted > max_accepted || generated > max_generated) {
if (accepted == 0) // ADDED! Otherwise the computed std dev is null; we're probably at equilibrium
{
///
cout << "Stopping: no accepted solution" << endl;
///
terminated = true;
return;
}
///
cout << (accepted > max_accepted? "MAXACC ": "MAXGEN ");
///
//double avgCost = costs_sum/(double)accepted;
//double stdDev = sqrt(varStat.value()); // WARNING: IT'S NO MORE THE AVG COST, NOW IT'S THE STD DEV!
//double variance = varStat.value();
double avgCost = momentStat.value().first;
double variance = momentStat.value().second;
double stdDev = sqrt(variance);
double sigma = stdDev;
double delta = sigma/mu2;
//outf << avgCost << endl;
outf << _temp << endl;
//outf << prevAvgCost-delta << endl;
accepted = generated = costs_sum = 0;
//momentStat.init(_solution);//TODONE use next chain's first sol
statIsInitialized = false;
///
cout << "T=" << _temp << " avgCost=" << avgCost << " stdDev=" << stdDev << " currCost=" << _solution.fitness() << endl;
///
double alpha;
double oldprevAvgCost = prevAvgCost;
///
cout << "negTemp: " << negative_temp << " / " << K2 << endl;
///
if (negative_temp < K2)
{
if (!reinitializing)
{
///
if (avgCost/(prevAvgCost-delta) > xi) cout << "/!\\ eq not reached!" << endl;
///
if (avgCost/(prevAvgCost-delta) > xi)
equilibrium_not_reached++;
else equilibrium_not_reached = 0;
}
if (equilibrium_not_reached > K1)
{
///
cout << "/!\\ Reinitializing (eq not reached)" << endl;
///
reinitializing = true;
alpha = lambda1;
delta = sigma/mu1;
equilibrium_not_reached = 0; // ADDED! Otherwise the algo gets trapped here!
}
else if (_temp*delta/(sigma*sigma) >= 1)
{
///
cout << "/!\\ neg temp!" << endl;
///
negative_temp++;
reinitializing = true;
if (negative_temp < K2)
{
alpha = lambda1;
delta = sigma/mu1;
} else
alpha = lambda2;
}
// First interpretation of the pseudocode indentation: (seems obviously false because it makes the above code unreachable)
/*
}
else
{
cout << "ccc" << endl;
reinitializing = false;
prevAvgCost = avgCost;
alpha = 1-_temp*delta/(sigma*sigma);
}
*/
// Second interpretation of the pseudocode indentation:
else
{
///
cout << "[normal decrease]" << endl;
///
reinitializing = false;
prevAvgCost = avgCost;
//alpha = 1-_temp*delta/(sigma*sigma);
alpha = 1-_temp*delta/variance;
//alpha = (sigma==0? 1: 1-_temp*delta/(sigma*sigma)); // ADDED! but removed
if (sigma == 0) // ADDED! When std dev is null, the solution is probably at eq, and the algo can't go on anyways
terminated = true, cout << "Stopping: null std dev" << endl;
}
}
// FIXME: else what? alpha=?
/**
* update the temperature by a factor
* @param _temp current temperature to update
* @param _acceptedMove true when the move is accepted, false otherwise
*/
void update(double& _temp, bool _acceptedMove, EOT & _solution) {
//cout << _temp << " g " << generated << endl;
generated++;
if (_acceptedMove)
{
accepted++;
//costs_sum += _solution.fitness();
//varStat(_solution);
if (statIsInitialized)
momentStat(_solution);
else momentStat.init(_solution), statIsInitialized = true;
//cout << _solution.fitness() << " avgCost=" << momentStat.value().first << endl;
}
if (accepted > max_accepted || generated > max_generated) {
if (accepted == 0) // ADDED! Otherwise the computed std dev is null; we're probably at equilibrium
{
///
cout << "Stopping: no accepted solution" << endl;
///
terminated = true;
return;
}
///
cout << (accepted > max_accepted? "MAXACC ": "MAXGEN ");
///
//double avgCost = costs_sum/(double)accepted;
//double stdDev = sqrt(varStat.value()); // WARNING: IT'S NO MORE THE AVG COST, NOW IT'S THE STD DEV!
//double variance = varStat.value();
double avgCost = momentStat.value().first;
double variance = momentStat.value().second;
double stdDev = sqrt(variance);
double sigma = stdDev;
double delta = sigma/mu2;
//outf << avgCost << endl;
outf << _temp << endl;
//outf << prevAvgCost-delta << endl;
accepted = generated = costs_sum = 0;
//momentStat.init(_solution);//TODONE use next chain's first sol
statIsInitialized = false;
///
cout << "T=" << _temp << " avgCost=" << avgCost << " stdDev=" << stdDev << " currCost=" << _solution.fitness() << endl;
///
double alpha;
double oldprevAvgCost = prevAvgCost;
///
cout << "negTemp: " << negative_temp << " / " << K2 << endl;
///
if (negative_temp < K2)
{
if (!reinitializing)
{
///
if (avgCost/(prevAvgCost-delta) > xi) cout << "/!\\ eq not reached!" << endl;
///
if (avgCost/(prevAvgCost-delta) > xi)
equilibrium_not_reached++;
else equilibrium_not_reached = 0;
}
if (equilibrium_not_reached > K1)
{
///
cout << "/!\\ Reinitializing (eq not reached)" << endl;
///
reinitializing = true;
alpha = lambda1;
delta = sigma/mu1;
equilibrium_not_reached = 0; // ADDED! Otherwise the algo gets trapped here!
}
else if (_temp*delta/(sigma*sigma) >= 1)
{
///
cout << "/!\\ neg temp!" << endl;
///
negative_temp++;
reinitializing = true;
if (negative_temp < K2)
{
alpha = lambda1;
delta = sigma/mu1;
} else
alpha = lambda2;
}
// First interpretation of the pseudocode indentation: (seems obviously false because it makes the above code unreachable)
/*
}
else
{
cout << "ccc" << endl;
reinitializing = false;
prevAvgCost = avgCost;
alpha = 1-_temp*delta/(sigma*sigma);
}
*/
// Second interpretation of the pseudocode indentation:
else
{
///
cout << "[normal decrease]" << endl;
///
reinitializing = false;
prevAvgCost = avgCost;
//alpha = 1-_temp*delta/(sigma*sigma);
alpha = 1-_temp*delta/variance;
//alpha = (sigma==0? 1: 1-_temp*delta/(sigma*sigma)); // ADDED! but removed
if (sigma == 0) // ADDED! When std dev is null, the solution is probably at eq, and the algo can't go on anyways
terminated = true, cout << "Stopping: null std dev" << endl;
}
}
// FIXME: else what? alpha=?
///
cout << "*=" << alpha << endl;
///
_temp *= alpha;
// Never seems to be used
if (avgCost == oldprevAvgCost) // use a neighborhood to approximate double equality?
frozen++;
else frozen = 0;
//exit(0);
//cin.get();
}
}
///
cout << "*=" << alpha << endl;
///
_temp *= alpha;
// Never seems to be used
if (avgCost == oldprevAvgCost) // use a neighborhood to approximate double equality?
frozen++;
else frozen = 0;
//exit(0);
//cin.get();
}
}
//! Function which proceeds to the cooling
/*!
*/
bool operator() (double temperature)
{
///
if (terminated) cout << "TERMINATED" << endl;
///
return frozen < theta
&& !terminated ; // ADDED! because 'frozen' doesn't terminate anything
}
//! Function which proceeds to the cooling
/*!
*/
bool operator() (double temperature)
{
///
if (terminated) cout << "TERMINATED" << endl;
///
return frozen < theta
&& !terminated ; // ADDED! because 'frozen' doesn't terminate anything
}
private:
//moNeighborhoodStat<Neighbor> nhStat;
//moStdFitnessNeighborStat<Neighbor> stdDevStat;
const double
// parameters of the algorithm
//currentTemp,
initTemp,
//ratio,
//threshold,
mu2, // mu2 typically belongs to [1; 20]
K1, // K1 in [1; 4], the number of chains without reaching equilibrium before we raise the temperature
K2,
lambda1, // the increase in temperature, typically in [1.5; 4]
lambda2, // lambda2 in [0.5; 0.99]
mu1, // target decrease in cost factor, in [2; 20]
xi // xi typically belongs to [1; 1.1]
// private variables
;
double
stdDev,
prevAvgCost,
expectedDecreaseInCost, // delta
costs_sum
;
const int
max_accepted,
max_generated,
theta // theta is typically set to 10
;
int
accepted,
generated,
equilibrium_not_reached,
negative_temp,
frozen
;
bool reinitializing, terminated;
//moFitnessVarianceStat<EOT> varStat;
moFitnessMomentsStat<EOT> momentStat;
bool statIsInitialized;
ofstream outf;
//private:
public://FIXME add friend
//moNeighborhoodStat<Neighbor> nhStat;
//moStdFitnessNeighborStat<Neighbor> stdDevStat;
const double
// parameters of the algorithm
//currentTemp,
initTemp,
//ratio,
//threshold,
mu2, // mu2 typically belongs to [1; 20]
K1, // K1 in [1; 4], the number of chains without reaching equilibrium before we raise the temperature
K2,
lambda1, // the increase in temperature, typically in [1.5; 4]
lambda2, // lambda2 in [0.5; 0.99]
mu1, // target decrease in cost factor, in [2; 20]
xi // xi typically belongs to [1; 1.1]
// private variables
;
double
stdDev,
prevAvgCost,
expectedDecreaseInCost, // delta
costs_sum
;
const int
max_accepted,
max_generated,
theta // theta is typically set to 10
;
int
accepted,
generated,
equilibrium_not_reached,
negative_temp,
frozen
;
bool reinitializing, terminated;
//moFitnessVarianceStat<EOT> varStat;
moFitnessMomentsStat<EOT> momentStat;
bool statIsInitialized;
ofstream outf;
};
#endif

220
mo/src/explorer/moSAexplorer.h
View file

@ -1,220 +0,0 @@
/*
<moSAexplorer.h>
Copyright (C) DOLPHIN Project-Team, INRIA Lille - Nord Europe, 2006-2010
Sébastien Verel, Arnaud Liefooghe, Jérémie Humeau
This software is governed by the CeCILL license under French law and
abiding by the rules of distribution of free software. You can use,
modify and/ or redistribute the software under the terms of the CeCILL
license as circulated by CEA, CNRS and INRIA at the following URL
"http://www.cecill.info".
As a counterpart to the access to the source code and rights to copy,
modify and redistribute granted by the license, users are provided only
with a limited warranty and the software's author, the holder of the
economic rights, and the successive licensors have only limited liability.
In this respect, the user's attention is drawn to the risks associated
with loading, using, modifying and/or developing or reproducing the
software by the user in light of its specific status of free software,
that may mean that it is complicated to manipulate, and that also
therefore means that it is reserved for developers and experienced
professionals having in-depth computer knowledge. Users are therefore
encouraged to load and test the software's suitability as regards their
requirements in conditions enabling the security of their systems and/or
data to be ensured and, more generally, to use and operate it in the
same conditions as regards security.
The fact that you are presently reading this means that you have had
knowledge of the CeCILL license and that you accept its terms.
ParadisEO WebSite : http://paradiseo.gforge.inria.fr
Contact: paradiseo-help@lists.gforge.inria.fr
*/
#ifndef _moSAexplorer_h
#define _moSAexplorer_h
#include <cstdlib>
#include <explorer/moNeighborhoodExplorer.h>
#include <comparator/moSolNeighborComparator.h>
#include <coolingSchedule/moCoolingSchedule.h>
#include <neighborhood/moNeighborhood.h>
#include <eoOptional.h>
#include <eval/moFullEvalByCopy.h>
#include <utils/eoRNG.h>
/**
* Explorer for the Simulated Annealing
* Only the symetric case is considered when Q(x,y) = Q(y,x)
* Fitness must be > 0
*
*/
template< class Neighbor >
class moSAexplorer : public moNeighborhoodExplorer<Neighbor>
{
public:
typedef typename Neighbor::EOT EOT ;
typedef moNeighborhood<Neighbor> Neighborhood ;
using moNeighborhoodExplorer<Neighbor>::neighborhood;
using moNeighborhoodExplorer<Neighbor>::eval;
using moNeighborhoodExplorer<Neighbor>::selectedNeighbor;
/**
* Constructor
* @param _neighborhood the neighborhood
* @param _eval the evaluation function
* @param _solNeighborComparator a solution vs neighbor comparator
* @param _coolingSchedule the cooling schedule
*/
/*
moSAexplorer (
Neighborhood& _neighborhood,
moEval<Neighbor>& _eval,
moSolNeighborComparator<Neighbor>& _solNeighborComparator,
moCoolingSchedule<EOT>& _coolingSchedule
)
: moNeighborhoodExplorer<Neighbor>(_neighborhood, _eval),
solNeighborComparator(_solNeighborComparator),
coolingSchedule(_coolingSchedule)
{
isAccept = false;
if (!neighborhood.isRandom()) {
std::cout << "moSAexplorer::Warning -> the neighborhood used is not random" << std::endl;
}
}*/
moSAexplorer (
Neighborhood& _neighborhood,
moCoolingSchedule<EOT>& _cool,
eoOptional< moEval<Neighbor> > _eval = NULL,
eoOptional< moSolNeighborComparator<Neighbor> > _comp = NULL
)
: moNeighborhoodExplorer<Neighbor>(_neighborhood, _eval.hasValue()? _eval.get(): *(default_eval = new moFullEvalByCopy<Neighbor>(_fullEval))),
default_eval(NULL), // removed in C++11 with unique_ptr
defaultSolNeighborComp(NULL), // removed in C++11 with unique_ptr
solNeighborComparator(_comp.hasValue()? _comp.get(): *(defaultSolNeighborComp = new moSolNeighborComparator<Neighbor>())),
coolingSchedule(_coolingSchedule)
{
isAccept = false;
if (!neighborhood.isRandom()) {
std::cout << "moSAexplorer::Warning -> the neighborhood used is not random" << std::endl;
}
}
/**
* Destructor
*/
~moSAexplorer() {
if (defaultSolNeighborComp != NULL)
delete defaultSolNeighborComp;
if (default_eval != NULL)
delete default_eval;
}
/**
* initialization of the initial temperature
* @param _solution the solution
*/
virtual void initParam(EOT & _solution) {
temperature = coolingSchedule.init(_solution);
isAccept = false;
};
/**
* decrease the temperature if necessary
* @param _solution unused solution
*/
virtual void updateParam(EOT & _solution) {
coolingSchedule.update(temperature, this->moveApplied(), _solution);
};
/**
* terminate: NOTHING TO DO
* @param _solution unused solution
*/
virtual void terminate(EOT & _solution) {};
/**
* Explore one random solution in the neighborhood
* @param _solution the solution
*/
virtual void operator()(EOT & _solution) {
//Test if _solution has a Neighbor
if (neighborhood.hasNeighbor(_solution)) {
//init on the first neighbor: supposed to be random solution in the neighborhood
neighborhood.init(_solution, selectedNeighbor);
//eval the _solution moved with the neighbor and stock the result in the neighbor
eval(_solution, selectedNeighbor);
}
else {
//if _solution hasn't neighbor,
isAccept=false;
}
};
/**
* continue if the temperature is not too low
* @param _solution the solution
* @return true if the criteria from the cooling schedule is true
*/
virtual bool isContinue(EOT & _solution) {
return coolingSchedule(temperature);
};
/**
* acceptance criterion according to the boltzmann criterion
* @param _solution the solution
* @return true if better neighbor or rnd < exp(delta f / T)
*/
virtual bool accept(EOT & _solution) {
if (neighborhood.hasNeighbor(_solution)) {
if (solNeighborComparator(_solution, selectedNeighbor)) // accept if the current neighbor is better than the solution
isAccept = true;
else {
double alpha=0.0;
double fit1, fit2;
fit1=(double)selectedNeighbor.fitness();
fit2=(double)_solution.fitness();
if (fit1 < fit2) // this is a maximization
alpha = exp((fit1 - fit2) / temperature );
else // this is a minimization
alpha = exp((fit2 - fit1) / temperature );
isAccept = (rng.uniform() < alpha) ;
}
}
return isAccept;
};
/**
* Getter
* @return the temperature
*/
double getTemperature() {
return temperature;
}
private:
moFullEvalByCopy<Neighbor>* default_eval;
moSolNeighborComparator<Neighbor>* defaultSolNeighborComp;
// comparator betwenn solution and neighbor
moSolNeighborComparator<Neighbor>& solNeighborComparator;
moCoolingSchedule<EOT>& coolingSchedule;
// temperatur of the process
double temperature;
// true if the move is accepted
bool isAccept ;
};
#endif