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

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

@ -67,9 +67,13 @@ public:
moLocalSearch<Neighbor>(explorer, trueCont, _fullEval) 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) 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), : moLocalSearch<Neighbor> (
defaultCool(new moSimpleCoolingSchedule<EOT>(_initT, _alpha, _span, _finalT)) explorer_ptr = defaultExplorer = new moSAexplorer<Neighbor>(_neighborhood, _eval, NULL, *(defaultCool = new moSimpleCoolingSchedule<EOT>(_initT, _alpha, _span, _finalT))),
//default_eval(NULL), // removed in C++11 with unique_ptr *(trueCont = new moTrueContinuator<Neighbor>()),
_fullEval ),
explorer(*explorer_ptr),
//defaultCool(),
default_eval(NULL) // removed in C++11 with unique_ptr
//defaultSolNeighborComp(new moSolNeighborComparator<Neighbor>()) //defaultSolNeighborComp(new moSolNeighborComparator<Neighbor>())
//explorer(_neighborhood, _eval, *defaultSolNeighborComp, *defaultCool) //explorer(_neighborhood, _eval, *defaultSolNeighborComp, *defaultCool)
{ } { }
@ -146,46 +150,76 @@ public:
_cool ) _cool )
{ }*/ { }*/
: moLocalSearch<Neighbor> ( : moLocalSearch<Neighbor> (
explorer = *(defaultExplorer = new moSAexplorer<Neighbor> ( explorer_ptr = defaultExplorer = new moSAexplorer<Neighbor> (
_neighborhood, _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>(), // C++11: _eval.hasValue()? _eval.get(): default_eval = new moFullEvalByCopy<Neighbor>(),
_comp, //_comp.hasValue()? _comp.get(): *(defaultSolNeighborComp = new moSolNeighborComparator<Neighbor>()), _comp, //_comp.hasValue()? _comp.get(): *(defaultSolNeighborComp = new moSolNeighborComparator<Neighbor>()),
_cool )), _cool ),
_cont.hasValue()? _cont.get(): *(trueCont = new moTrueContinuator<Neighbor>()), _cont.hasValue()? trueCont = NULL, _cont.get(): *(trueCont = new moTrueContinuator<Neighbor>()),
_fullEval ), _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 defaultCool(NULL), // removed in C++11 with unique_ptr
//default_eval(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 trueCont(NULL) // removed in C++11 with unique_ptr
//defaultSolNeighborComp(NULL) // removed in C++11 with unique_ptr //defaultSolNeighborComp(NULL) // removed in C++11 with unique_ptr
{ } { }
/*
moSA ( moSA (
eoEvalFunc<EOT>& _fullEval,
moSAexplorer<Neighbor>& _explorer, moSAexplorer<Neighbor>& _explorer,
eoOptional< moContinuator<Neighbor> > _cont = NULL moContinuator<Neighbor> _cont
) )
: moLocalSearch<Neighbor> ( : moLocalSearch<Neighbor> (
*(explorer = &_explorer), *(explorer = &_explorer),
_cont.hasValue()? _cont.get(): *(trueCont = new moTrueContinuator<Neighbor>()), _fullEval ), _cont, _fullEval ),
defaultExplorer(NULL), // removed in C++11 with unique_ptr defaultExplorer(NULL), // removed in C++11 with unique_ptr
defaultCool(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 //default_eval(NULL), // removed in C++11 with unique_ptr
trueCont(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 //defaultSolNeighborComp(NULL) // removed in C++11 with unique_ptr
{ } { }
*/
virtual ~moSA () virtual ~moSA ()
{ {
// Note: using unique_ptr would allow us to remove this explicit destructor, but they were only introduced in C++11 // Note: using unique_ptr would allow us to remove this explicit destructor, but they were only introduced in C++11
if (trueCont != NULL) if (trueCont != NULL)
delete trueCont; delete trueCont;
if (explorer != NULL) if (defaultExplorer != NULL)
delete explorer; delete defaultExplorer;
if (default_eval != NULL)
delete default_eval;
} }
private: private:
moFullEvalByCopy<Neighbor>* default_eval;
moSAexplorer<Neighbor>* defaultExplorer; 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>> moSimpleCoolingSchedule<EOT>* defaultCool; // C++11: const std::unique_ptr<moSimpleCoolingSchedule<EOT>>
//moFullEvalByCopy<Neighbor>* default_eval; //moFullEvalByCopy<Neighbor>* default_eval;
moTrueContinuator<Neighbor>* trueCont; 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 > class moTrikiCoolingSchedule: public moCoolingSchedule< EOT >
{ {
public: public:
//typedef typename Neighbor::EOT EOT ; //typedef typename Neighbor::EOT EOT ;
typedef moNeighborhood<Neighbor> Neighborhood ; typedef moNeighborhood<Neighbor> Neighborhood ;
//! Constructor //! Constructor
/*! /*!
*/ */
moTrikiCoolingSchedule (Neighborhood& _neighborhood, moEval<Neighbor>& _eval, double _initTemp) moTrikiCoolingSchedule (Neighborhood& _neighborhood, moEval<Neighbor>& _eval, double _initTemp)
: initTemp(_initTemp), : initTemp(_initTemp),
mu2(10), // mu2 typically belongs to [1; 20] 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 K1(2), // K1 in [1; 4], the number of chains without reaching equilibrium before we raise the temperature
K2(5), // ??? K2(5), // ???
lambda1(2), // the increase in temperature, typically in [1.5; 4] lambda1(2), // the increase in temperature, typically in [1.5; 4]
lambda2(.7), // lambda2 in [0.5; 0.99] lambda2(.7), // lambda2 in [0.5; 0.99]
mu1(10), // target decrease in cost factor, in [2; 20] mu1(10), // target decrease in cost factor, in [2; 20]
xi(1.05), // xi typically belongs to [1; 1.1] xi(1.05), // xi typically belongs to [1; 1.1]
max_accepted(50), // depends on pb/neighborhood max_accepted(50), // depends on pb/neighborhood
max_generated(100), // depends on pb/neighborhood max_generated(100), // depends on pb/neighborhood
theta(10), // theta is typically set to 10 theta(10), // theta is typically set to 10
statIsInitialized(false), statIsInitialized(false),
outf("out.data") outf("out.data")
{ } { }
moTrikiCoolingSchedule ( moTrikiCoolingSchedule (
Neighborhood& _neighborhood, moEval<Neighbor>& _eval, double _initTemp, Neighborhood& _neighborhood, moEval<Neighbor>& _eval, double _initTemp,
double _max_accepted, double _max_accepted,
double _max_generated double _max_generated
) )
: initTemp(_initTemp), : initTemp(_initTemp),
mu2(10), // mu2 typically belongs to [1; 20] 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 K1(2), // K1 in [1; 4], the number of chains without reaching equilibrium before we raise the temperature
K2(5), // ??? K2(5), // ???
lambda1(2), // the increase in temperature, typically in [1.5; 4] lambda1(2), // the increase in temperature, typically in [1.5; 4]
lambda2(.7), // lambda2 in [0.5; 0.99] lambda2(.7), // lambda2 in [0.5; 0.99]
mu1(10), // target decrease in cost factor, in [2; 20] mu1(10), // target decrease in cost factor, in [2; 20]
xi(1.05), // xi typically belongs to [1; 1.1] xi(1.05), // xi typically belongs to [1; 1.1]
max_accepted(_max_accepted), // depends on pb/neighborhood max_accepted(_max_accepted), // depends on pb/neighborhood
max_generated(_max_generated), // depends on pb/neighborhood max_generated(_max_generated), // depends on pb/neighborhood
theta(10), // theta is typically set to 10 theta(10), // theta is typically set to 10
statIsInitialized(false), statIsInitialized(false),
outf("out.data") outf("out.data")
{ } { }
/** /**
* Initial temperature * Initial temperature
* @param _solution initial solution * @param _solution initial solution
*/ */
double init(EOT & _solution) { double init(EOT & _solution) {
accepted = generated = costs_sum = 0; accepted = generated = costs_sum = 0;
negative_temp = equilibrium_not_reached = frozen = 0; negative_temp = equilibrium_not_reached = frozen = 0;
reinitializing = false; reinitializing = false;
terminated = false; terminated = false;
statIsInitialized = false; statIsInitialized = false;
/// ///
cout << "INIT T=" << initTemp << endl; cout << "INIT T=" << initTemp << endl;
/// ///
//outf.open("out"); //outf.open("out");
//outf << "ok"; //outf << "ok";
//outf.close(); //outf.close();
return initTemp; return initTemp;
} }
/** /**
* update the temperature by a factor * update the temperature by a factor
* @param _temp current temperature to update * @param _temp current temperature to update
* @param _acceptedMove true when the move is accepted, false otherwise * @param _acceptedMove true when the move is accepted, false otherwise
*/ */
void update(double& _temp, bool _acceptedMove, EOT & _solution) { void update(double& _temp, bool _acceptedMove, EOT & _solution) {
//cout << _temp << " g " << generated << endl; //cout << _temp << " g " << generated << endl;
generated++; generated++;
if (_acceptedMove) if (_acceptedMove)
{ {
accepted++; accepted++;
//costs_sum += _solution.fitness(); //costs_sum += _solution.fitness();
//varStat(_solution); //varStat(_solution);
if (statIsInitialized) if (statIsInitialized)
momentStat(_solution); momentStat(_solution);
else momentStat.init(_solution), statIsInitialized = true; else momentStat.init(_solution), statIsInitialized = true;
//cout << _solution.fitness() << " avgCost=" << momentStat.value().first << endl; //cout << _solution.fitness() << " avgCost=" << momentStat.value().first << endl;
} }
if (accepted > max_accepted || generated > max_generated) { if (accepted > max_accepted || generated > max_generated) {
if (accepted == 0) // ADDED! Otherwise the computed std dev is null; we're probably at equilibrium if (accepted == 0) // ADDED! Otherwise the computed std dev is null; we're probably at equilibrium
{ {
/// ///
cout << "Stopping: no accepted solution" << endl; cout << "Stopping: no accepted solution" << endl;
/// ///
terminated = true; terminated = true;
return; return;
} }
/// ///
cout << (accepted > max_accepted? "MAXACC ": "MAXGEN "); cout << (accepted > max_accepted? "MAXACC ": "MAXGEN ");
/// ///
//double avgCost = costs_sum/(double)accepted; //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 stdDev = sqrt(varStat.value()); // WARNING: IT'S NO MORE THE AVG COST, NOW IT'S THE STD DEV!
//double variance = varStat.value(); //double variance = varStat.value();
double avgCost = momentStat.value().first; double avgCost = momentStat.value().first;
double variance = momentStat.value().second; double variance = momentStat.value().second;
double stdDev = sqrt(variance); double stdDev = sqrt(variance);
double sigma = stdDev; double sigma = stdDev;
double delta = sigma/mu2; double delta = sigma/mu2;
//outf << avgCost << endl; //outf << avgCost << endl;
outf << _temp << endl; outf << _temp << endl;
//outf << prevAvgCost-delta << endl; //outf << prevAvgCost-delta << endl;
accepted = generated = costs_sum = 0; accepted = generated = costs_sum = 0;
//momentStat.init(_solution);//TODONE use next chain's first sol //momentStat.init(_solution);//TODONE use next chain's first sol
statIsInitialized = false; statIsInitialized = false;
/// ///
cout << "T=" << _temp << " avgCost=" << avgCost << " stdDev=" << stdDev << " currCost=" << _solution.fitness() << endl; cout << "T=" << _temp << " avgCost=" << avgCost << " stdDev=" << stdDev << " currCost=" << _solution.fitness() << endl;
/// ///
double alpha; double alpha;
double oldprevAvgCost = prevAvgCost; double oldprevAvgCost = prevAvgCost;
/// ///
cout << "negTemp: " << negative_temp << " / " << K2 << endl; cout << "negTemp: " << negative_temp << " / " << K2 << endl;
/// ///
if (negative_temp < K2) if (negative_temp < K2)
{ {
if (!reinitializing) if (!reinitializing)
{ {
/// ///
if (avgCost/(prevAvgCost-delta) > xi) cout << "/!\\ eq not reached!" << endl; if (avgCost/(prevAvgCost-delta) > xi) cout << "/!\\ eq not reached!" << endl;
/// ///
if (avgCost/(prevAvgCost-delta) > xi) if (avgCost/(prevAvgCost-delta) > xi)
equilibrium_not_reached++; equilibrium_not_reached++;
else equilibrium_not_reached = 0; else equilibrium_not_reached = 0;
} }
if (equilibrium_not_reached > K1) if (equilibrium_not_reached > K1)
{ {
/// ///
cout << "/!\\ Reinitializing (eq not reached)" << endl; cout << "/!\\ Reinitializing (eq not reached)" << endl;
/// ///
reinitializing = true; reinitializing = true;
alpha = lambda1; alpha = lambda1;
delta = sigma/mu1; delta = sigma/mu1;
equilibrium_not_reached = 0; // ADDED! Otherwise the algo gets trapped here! equilibrium_not_reached = 0; // ADDED! Otherwise the algo gets trapped here!
} }
else if (_temp*delta/(sigma*sigma) >= 1) else if (_temp*delta/(sigma*sigma) >= 1)
{ {
/// ///
cout << "/!\\ neg temp!" << endl; cout << "/!\\ neg temp!" << endl;
/// ///
negative_temp++; negative_temp++;
reinitializing = true; reinitializing = true;
if (negative_temp < K2) if (negative_temp < K2)
{ {
alpha = lambda1; alpha = lambda1;
delta = sigma/mu1; delta = sigma/mu1;
} else } else
alpha = lambda2; alpha = lambda2;
} }
// First interpretation of the pseudocode indentation: (seems obviously false because it makes the above code unreachable) // First interpretation of the pseudocode indentation: (seems obviously false because it makes the above code unreachable)
/* /*
} }
else else
{ {
cout << "ccc" << endl; cout << "ccc" << endl;
reinitializing = false; reinitializing = false;
prevAvgCost = avgCost; prevAvgCost = avgCost;
alpha = 1-_temp*delta/(sigma*sigma); alpha = 1-_temp*delta/(sigma*sigma);
} }
*/ */
// Second interpretation of the pseudocode indentation: // Second interpretation of the pseudocode indentation:
else else
{ {
/// ///
cout << "[normal decrease]" << endl; cout << "[normal decrease]" << endl;
/// ///
reinitializing = false; reinitializing = false;
prevAvgCost = avgCost; prevAvgCost = avgCost;
//alpha = 1-_temp*delta/(sigma*sigma); //alpha = 1-_temp*delta/(sigma*sigma);
alpha = 1-_temp*delta/variance; alpha = 1-_temp*delta/variance;
//alpha = (sigma==0? 1: 1-_temp*delta/(sigma*sigma)); // ADDED! but removed //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 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; terminated = true, cout << "Stopping: null std dev" << endl;
} }
} }
// FIXME: else what? alpha=? // FIXME: else what? alpha=?
/// ///
cout << "*=" << alpha << endl; cout << "*=" << alpha << endl;
/// ///
_temp *= alpha; _temp *= alpha;
// Never seems to be used // Never seems to be used
if (avgCost == oldprevAvgCost) // use a neighborhood to approximate double equality? if (avgCost == oldprevAvgCost) // use a neighborhood to approximate double equality?
frozen++; frozen++;
else frozen = 0; else frozen = 0;
//exit(0); //exit(0);
//cin.get(); //cin.get();
} }
} }
//! Function which proceeds to the cooling //! Function which proceeds to the cooling
/*! /*!
*/ */
bool operator() (double temperature) bool operator() (double temperature)
{ {
/// ///
if (terminated) cout << "TERMINATED" << endl; if (terminated) cout << "TERMINATED" << endl;
/// ///
return frozen < theta return frozen < theta
&& !terminated ; // ADDED! because 'frozen' doesn't terminate anything && !terminated ; // ADDED! because 'frozen' doesn't terminate anything
} }
private: //private:
//moNeighborhoodStat<Neighbor> nhStat; public://FIXME add friend
//moStdFitnessNeighborStat<Neighbor> stdDevStat; //moNeighborhoodStat<Neighbor> nhStat;
const double //moStdFitnessNeighborStat<Neighbor> stdDevStat;
// parameters of the algorithm const double
//currentTemp, // parameters of the algorithm
initTemp, //currentTemp,
//ratio, initTemp,
//threshold, //ratio,
mu2, // mu2 typically belongs to [1; 20] //threshold,
K1, // K1 in [1; 4], the number of chains without reaching equilibrium before we raise the temperature mu2, // mu2 typically belongs to [1; 20]
K2, K1, // K1 in [1; 4], the number of chains without reaching equilibrium before we raise the temperature
lambda1, // the increase in temperature, typically in [1.5; 4] K2,
lambda2, // lambda2 in [0.5; 0.99] lambda1, // the increase in temperature, typically in [1.5; 4]
mu1, // target decrease in cost factor, in [2; 20] lambda2, // lambda2 in [0.5; 0.99]
xi // xi typically belongs to [1; 1.1] mu1, // target decrease in cost factor, in [2; 20]
// private variables xi // xi typically belongs to [1; 1.1]
; // private variables
double ;
stdDev, double
prevAvgCost, stdDev,
expectedDecreaseInCost, // delta prevAvgCost,
costs_sum expectedDecreaseInCost, // delta
; costs_sum
const int ;
max_accepted, const int
max_generated, max_accepted,
theta // theta is typically set to 10 max_generated,
; theta // theta is typically set to 10
int ;
accepted, int
generated, accepted,
equilibrium_not_reached, generated,
negative_temp, equilibrium_not_reached,
frozen negative_temp,
; frozen
bool reinitializing, terminated; ;
bool reinitializing, terminated;
//moFitnessVarianceStat<EOT> varStat;
moFitnessMomentsStat<EOT> momentStat; //moFitnessVarianceStat<EOT> varStat;
bool statIsInitialized; moFitnessMomentsStat<EOT> momentStat;
bool statIsInitialized;
ofstream outf;
ofstream outf;
}; };
#endif #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