From b4b7c583fe61a51ff66486e762b50aa53ff0edf5 Mon Sep 17 00:00:00 2001 From: verel Date: Tue, 6 Dec 2011 21:20:50 +0000 Subject: [PATCH] Add the double incremental evaluation for UBQP git-svn-id: svn://scm.gforge.inria.fr/svnroot/paradiseo@2552 331e1502-861f-0410-8da2-ba01fb791d7f --- .../src/eval/moDoubleIncrEvaluation.h | 6 +- .../src/eval/moUBQPdoubleIncrEvaluation.h | 203 ++++++++++++++++++ 2 files changed, 207 insertions(+), 2 deletions(-) create mode 100644 trunk/paradiseo-mo/src/eval/moUBQPdoubleIncrEvaluation.h diff --git a/trunk/paradiseo-mo/src/eval/moDoubleIncrEvaluation.h b/trunk/paradiseo-mo/src/eval/moDoubleIncrEvaluation.h index f3136f00c..ed647d93e 100644 --- a/trunk/paradiseo-mo/src/eval/moDoubleIncrEvaluation.h +++ b/trunk/paradiseo-mo/src/eval/moDoubleIncrEvaluation.h @@ -70,7 +70,7 @@ public: * */ virtual void init() { - firstEval = false; + firstEval = true; } /** @@ -82,7 +82,9 @@ public: virtual operator()(EOT & _solution) { } - /** the delta of fitness for each neighbors */ + /** the delta of fitness for each neighbors + * The fitness of the neighbor i is given by : fitness(solution) + deltaFitness[i] + */ Fitness * deltaFitness; protected: diff --git a/trunk/paradiseo-mo/src/eval/moUBQPdoubleIncrEvaluation.h b/trunk/paradiseo-mo/src/eval/moUBQPdoubleIncrEvaluation.h new file mode 100644 index 000000000..f4a028e54 --- /dev/null +++ b/trunk/paradiseo-mo/src/eval/moUBQPdoubleIncrEvaluation.h @@ -0,0 +1,203 @@ +/* + + Copyright (C) DOLPHIN Project-Team, INRIA Lille - Nord Europe, 2006-2010 + + Sebastien Verel, Arnaud Liefooghe, Jeremie 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 moUBQPdoubleIncrEvaluation_H +#define moUBQPdoubleIncrEvaluation_H + +#include +#include +#include + +/** + * The neighborhood evaluation for the UBQP + * The double incremental evaluation is used + * + */ +template +class moUBQPdoubleIncrEvaluation : public moNeighborhoodEvaluation, moUpdater +{ +public: + using moDoubleIncrEvaluation::deltaFitness; + + /** + * Constructor + * + * @param _neighborhoodSize the size of the neighborhood + * @param _searchExplorer the neighborhood explorer of the local search + * @param _incrEval the incremental evaluation of the UBQP + */ + moUBQPdoubleIncrEvaluation(unsigned int _neighborhoodSize, moNeighborhoodExplorer & _searchExplorer, moEval & _incrEval) : moDoubleIncrNeighborhoodEvaluation(_neighborhoodSize), searchExplorer(_searchExplorer) + { + n = _incrEval.getNbVar(); + Q = _incrEval.getQ(); + } + + + /** + * Evaluation of the neighborhood + * Here nothing to do + * + * @param _solution the current solution + */ + virtual operator()(EOT & _solution) { + if (firstEval) { + firstEval = false; + + // compute the delta in the simple incremental way O(n) + unsigned int j; + int d; + for(unsigned i = 0; i < n; i++) { + d = Q[i][i]; + + for(j = 0; j < i; j++) + if (_solution[j]) + d += Q[i][j]; + + for(j = i+1; j < n; j++) + if (_solution[j]) + d += Q[j][i]; + + if (_solution[i]) + d = - d; + + deltaFitness[i] = d; + } + } else { + + if (searchExplorer.moveApplied()) { // compute the new fitness only when the solution has moved + // the currentNeighbor is the previous neighbor + // the movement is made on this neighbor + // we suppose that the neighborhood is bit string neighborhood (indexed neighbor) + unsigned iMove = searchExplorer.currentNeighbor.index(); + + for(unsigned i = 0; i < n; i++) { + if (i == iMove) + deltaFitness[i] = - deltaFitness[i] ; + else { + if (_solution[i] != _solution[iMove]) + if (i < iMove) + deltaFitness[i] += Q[iMove][i]; + else + deltaFitness[i] += Q[i][iMove]; + else + if (i < iMove) + deltaFitness[i] -= Q[iMove][i]; + else + deltaFitness[i] -= Q[i][iMove]; + } + } + } + } + } + + /* + * to get the matrix Q + * + * @return matrix Q + */ + int** getQ() { + return Q; + } + + /* + * to get the number of variable (bit string length) + * + * @return bit string length + */ + int getNbVar() { + return n; + } + +private: + /** + * compute the delta of fitness in linear time (incremental evaluation) + * + * @param i the neighbor to consider + */ + /* + void fullDelta(unsigned int i) { + unsigned int j; + + int d = Q[i][i]; + + for(j = 0; j < i; j++) + if (current[j]) + d += Q[i][j]; + + for(j = i+1; j < n; j++) + if (current[j]) + d += Q[j][i]; + + if (current[i]) + d = - d; + + delta[i] = d; + } +*/ + + /** + * compute the delta of delta in constant time (3 tests and 1 operation) + * + * @param i the neighbor to consider + */ + /* + void updateDelta(unsigned int i) { + if (i == iMove) + delta[i] = - delta[i] ; + else { + if (current[i] != current[iMove]) + if (i < iMove) + delta[i] += Q[iMove][i]; + else + delta[i] += Q[i][iMove]; + else + if (i < iMove) + delta[i] -= Q[iMove][i]; + else + delta[i] -= Q[i][iMove]; + } + } + */ + + // number of variables + int n; + + // matrix Q (supposed to be in lower triangular form) + int ** Q; + + /** The search explorer of the local search */ + moNeighborhoodExplorer & searchExplorer; +}; + +#endif