diff --git a/mo/src/algo/moLocalSearch.h b/mo/src/algo/moLocalSearch.h index bf77a8f3f..0c125d62a 100644 --- a/mo/src/algo/moLocalSearch.h +++ b/mo/src/algo/moLocalSearch.h @@ -47,99 +47,97 @@ template class moLocalSearch: public eoMonOp { public: - typedef moNeighborhood Neighborhood; - typedef moNeighborhoodExplorer NeighborhoodExplorer; - typedef typename Neighbor::EOT EOT; + typedef moNeighborhood Neighborhood; + typedef moNeighborhoodExplorer 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 & _cont, eoEvalFunc& _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 & _cont, eoEvalFunc& _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 & _cont) { - cont = &_cont; - } + /** + * Set an external continuator + * @param _cont the external continuator + */ + void setContinuator(moContinuator & _cont) { + cont = &_cont; + } - /** - * external continuator object - * - * @overload - * @return the external continuator - */ - moContinuator* getContinuator() const { - return cont; - } + /** + * external continuator object + * + * @overload + * @return the external continuator + */ + moContinuator* getContinuator() const { + return cont; + } - /** - * to get the neighborhood explorer - * - * @overload - * @return the neighborhood explorer - */ - moNeighborhoodExplorer & getNeighborhoodExplorer() const { - return searchExplorer; - } + /** + * to get the neighborhood explorer + * + * @overload + * @return the neighborhood explorer + */ + moNeighborhoodExplorer & getNeighborhoodExplorer() const { + return searchExplorer; + } protected: - // make the exploration of the neighborhood according to a local search heuristic - moNeighborhoodExplorer& searchExplorer; + // make the exploration of the neighborhood according to a local search heuristic + moNeighborhoodExplorer& searchExplorer; - // external continuator - moContinuator * cont; + // external continuator + moContinuator * cont; - //full evaluation function - eoEvalFunc& fullEval; + //full evaluation function + eoEvalFunc& fullEval; }; #endif diff --git a/mo/src/algo/moSA.h b/mo/src/algo/moSA.h index 49d8e4c0d..89c61ad3a 100644 --- a/mo/src/algo/moSA.h +++ b/mo/src/algo/moSA.h @@ -67,9 +67,13 @@ public: moLocalSearch(explorer, trueCont, _fullEval) { }*/ moSA(Neighborhood& _neighborhood, eoEvalFunc& _fullEval, moEval& _eval, double _initT=10, double _alpha=0.9, unsigned _span=100, double _finalT=0.01) - : moLocalSearch(explorer = *(defaultExplorer = new moSAexplorer(_neighborhood, _eval, *defaultSolNeighborComp, *defaultCool)), *(trueCont = new moTrueContinuator()), _fullEval), - defaultCool(new moSimpleCoolingSchedule(_initT, _alpha, _span, _finalT)) - //default_eval(NULL), // removed in C++11 with unique_ptr + : moLocalSearch ( + explorer_ptr = defaultExplorer = new moSAexplorer(_neighborhood, _eval, NULL, *(defaultCool = new moSimpleCoolingSchedule(_initT, _alpha, _span, _finalT))), + *(trueCont = new moTrueContinuator()), + _fullEval ), + explorer(*explorer_ptr), + //defaultCool(), + default_eval(NULL) // removed in C++11 with unique_ptr //defaultSolNeighborComp(new moSolNeighborComparator()) //explorer(_neighborhood, _eval, *defaultSolNeighborComp, *defaultCool) { } @@ -146,46 +150,76 @@ public: _cool ) { }*/ : moLocalSearch ( - explorer = *(defaultExplorer = new moSAexplorer ( + explorer_ptr = defaultExplorer = new moSAexplorer ( _neighborhood, - _eval, //_eval.hasValue()? _eval.get(): *(default_eval = new moFullEvalByCopy(_fullEval)), + //_eval, //_eval.hasValue()? _eval.get(): *(default_eval = new moFullEvalByCopy(_fullEval)), + _eval.hasValue()? default_eval = NULL, _eval.get(): *(default_eval = new moFullEvalByCopy(_fullEval)), // C++11: _eval.hasValue()? _eval.get(): default_eval = new moFullEvalByCopy(), _comp, //_comp.hasValue()? _comp.get(): *(defaultSolNeighborComp = new moSolNeighborComparator()), - _cool )), - _cont.hasValue()? _cont.get(): *(trueCont = new moTrueContinuator()), + _cool ), + _cont.hasValue()? trueCont = NULL, _cont.get(): *(trueCont = new moTrueContinuator()), _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& _fullEval, + moSAexplorer& _explorer, + eoOptional< moContinuator > _cont = NULL + ) + : moLocalSearch ( + *(explorer_ptr = &_explorer), + _cont.hasValue()? _cont.get(): *(trueCont = new moTrueContinuator()), _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& _fullEval, moSAexplorer& _explorer, - eoOptional< moContinuator > _cont = NULL + moContinuator _cont ) : moLocalSearch ( *(explorer = &_explorer), - _cont.hasValue()? _cont.get(): *(trueCont = new moTrueContinuator()), _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* default_eval; moSAexplorer* defaultExplorer; - moSAexplorer& explorer; // Not NULL (ref) + moSAexplorer* explorer_ptr; // Not NULL + moSAexplorer& explorer; moSimpleCoolingSchedule* defaultCool; // C++11: const std::unique_ptr> //moFullEvalByCopy* default_eval; moTrueContinuator* trueCont; diff --git a/mo/src/coolingSchedule/moTrikiCoolingSchedule.h b/mo/src/coolingSchedule/moTrikiCoolingSchedule.h index 202b2d2f2..5c1e7e0c8 100644 --- a/mo/src/coolingSchedule/moTrikiCoolingSchedule.h +++ b/mo/src/coolingSchedule/moTrikiCoolingSchedule.h @@ -55,297 +55,298 @@ template< class EOT, class Neighbor > //, class Neighborhood > class moTrikiCoolingSchedule: public moCoolingSchedule< EOT > { public: - //typedef typename Neighbor::EOT EOT ; - typedef moNeighborhood Neighborhood ; + //typedef typename Neighbor::EOT EOT ; + typedef moNeighborhood Neighborhood ; - //! Constructor - /*! - */ + //! Constructor + /*! + */ - moTrikiCoolingSchedule (Neighborhood& _neighborhood, moEval& _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& _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& _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& _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 nhStat; - //moStdFitnessNeighborStat 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 varStat; - moFitnessMomentsStat momentStat; - bool statIsInitialized; - - ofstream outf; - +//private: +public://FIXME add friend + //moNeighborhoodStat nhStat; + //moStdFitnessNeighborStat 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 varStat; + moFitnessMomentsStat momentStat; + bool statIsInitialized; + + ofstream outf; + }; #endif diff --git a/mo/src/explorer/moSAexplorer.h b/mo/src/explorer/moSAexplorer.h deleted file mode 100644 index 09eda6dab..000000000 --- a/mo/src/explorer/moSAexplorer.h +++ /dev/null @@ -1,220 +0,0 @@ -/* - - 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 - -#include -#include -#include -#include -#include -#include - -#include - -/** - * 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 -{ -public: - typedef typename Neighbor::EOT EOT ; - typedef moNeighborhood Neighborhood ; - - using moNeighborhoodExplorer::neighborhood; - using moNeighborhoodExplorer::eval; - using moNeighborhoodExplorer::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& _eval, - moSolNeighborComparator& _solNeighborComparator, - moCoolingSchedule& _coolingSchedule - ) - : moNeighborhoodExplorer(_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& _cool, - eoOptional< moEval > _eval = NULL, - eoOptional< moSolNeighborComparator > _comp = NULL - ) - : moNeighborhoodExplorer(_neighborhood, _eval.hasValue()? _eval.get(): *(default_eval = new moFullEvalByCopy(_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())), - 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* default_eval; - moSolNeighborComparator* defaultSolNeighborComp; - - // comparator betwenn solution and neighbor - moSolNeighborComparator& solNeighborComparator; - - moCoolingSchedule& coolingSchedule; - - // temperatur of the process - double temperature; - - // true if the move is accepted - bool isAccept ; -}; - - -#endif