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

git-svn-id: svn://scm.gforge.inria.fr/svnroot/paradiseo@2704 331e1502-861f-0410-8da2-ba01fb791d7f

Browse source
This commit is contained in:
boufaras 2012-01-30 13:20:20 +00:00
commit abe9f76cc2
101 changed files with 0 additions and 9679 deletions
Download patch file Download diff file Expand all files Collapse all files

7
tags/ParadisEO-GPU-1.1/paradiseo-mo/CTestCustom.cmake
View file

@ -1,7 +0,0 @@
SET(CTEST_CUSTOM_COVERAGE_EXCLUDE
${CTEST_CUSTOM_COVERAGE_EXCLUDE}
"test/"
"paradiseo-eo/"
"problems/"
"tutorial/"
)

130
tags/ParadisEO-GPU-1.1/paradiseo-mo/install.cmake
View file

@ -1,130 +0,0 @@
######################################################################################
### CMake basic configuration
######################################################################################
# check cmake version compatibility
CMAKE_MINIMUM_REQUIRED(VERSION 2.6)
# regular expression checking
INCLUDE_REGULAR_EXPRESSION("^.*$" "^$")
# set a language for the entire project.
ENABLE_LANGUAGE(CXX)
ENABLE_LANGUAGE(C)
####################################################################################
#####################################################################################
### Include required modules & utilities
#####################################################################################
INCLUDE(CMakeBackwardCompatibilityCXX)
INCLUDE(FindDoxygen)
INCLUDE(FindGnuplot)
INCLUDE(CheckLibraryExists)
INCLUDE(Dart OPTIONAL)
INCLUDE(CPack)
# Set a special flag if the environment is windows (should do the same in a config.g file)
IF (WIN32)
ADD_DEFINITIONS(-D_WINDOWS=1)
ENDIF (WIN32)
######################################################################################
#####################################################################################
### Manage the build type
#####################################################################################
# the user should choose the build type on windows environments,excepted under cygwin (default=none)
SET(CMAKE_DEFAULT_BUILD_TYPE "Release" CACHE STRING "Variable that stores the default CMake build type" FORCE)
FIND_PROGRAM(MEMORYCHECK_COMMAND
NAMES purify valgrind
PATHS
"/usr/local/bin /usr/bin [HKEY_LOCAL_MACHINE\\SOFTWARE\\Rational Software\\Purify\\Setup;InstallFolder]"
DOC "Path to the memory checking command, used for memory error detection.")
IF(NOT CMAKE_BUILD_TYPE)
SET( CMAKE_BUILD_TYPE
${CMAKE_DEFAULT_BUILD_TYPE} CACHE STRING
"Choose the type of build, options are: Debug Release RelWithDebInfo MinSizeRel."
FORCE)
ENDIF(NOT CMAKE_BUILD_TYPE)
IF(WIN32 AND NOT CYGWIN)
IF(CMAKE_CXX_COMPILER MATCHES cl)
IF(NOT WITH_SHARED_LIBS)
IF(CMAKE_GENERATOR STREQUAL "Visual Studio 8 2005" OR CMAKE_GENERATOR STREQUAL "Visual Studio 9 2008" OR CMAKE_GENERATOR STREQUAL "Visual Studio 10")
SET(CMAKE_CXX_FLAGS "/nologo /Gy")
SET(CMAKE_CXX_FLAGS_DEBUG "/W3 /MTd /Z7 /Od")
SET(CMAKE_CXX_FLAGS_RELEASE "/w /MT /O2 /wd4530")
SET(CMAKE_CXX_FLAGS_MINSIZEREL "/MT /O2")
SET(CMAKE_CXX_FLAGS_RELWITHDEBINFO "/MTd /Z7 /Od")
SET(CMAKE_EXE_LINKER_FLAGS "${CMAKE_EXE_LINKER_FLAGS} /SUBSYSTEM:CONSOLE")
ENDIF(CMAKE_GENERATOR STREQUAL "Visual Studio 8 2005" OR CMAKE_GENERATOR STREQUAL "Visual Studio 9 2008" OR CMAKE_GENERATOR STREQUAL "Visual Studio 10")
ENDIF(NOT WITH_SHARED_LIBS)
ENDIF(CMAKE_CXX_COMPILER MATCHES cl)
ELSE(WIN32 AND NOT CYGWIN)
IF(CMAKE_COMPILER_IS_GNUCXX)
SET(CMAKE_CXX_FLAGS_DEBUG "${CMAKE_CXX_FLAGS_DEBUG} -O0 -g -fprofile-arcs -ftest-coverage -Wall -Wextra -Wno-unused-parameter -Wno-ignored-qualifiers")
SET(CMAKE_CXX_FLAGS_RELEASE "${CMAKE_CXX_FLAGS_RELEASE} -O2")
SET(CMAKE_CXX_FLAGS_MINSIZEREL "${CMAKE_CXX_FLAGS_MINSIZEREL} -O6")
ENDIF(CMAKE_COMPILER_IS_GNUCXX)
ENDIF(WIN32 AND NOT CYGWIN)
IF(CMAKE_BUILD_TYPE MATCHES Debug)
ADD_DEFINITIONS(-DCMAKE_VERBOSE_MAKEFILE=ON)
ENDIF(CMAKE_BUILD_TYPE MATCHES Debug)
#####################################################################################
######################################################################################
### compilation of examples?
######################################################################################
SET(ENABLE_CMAKE_EXAMPLE TRUE CACHE BOOL "Enable copy of benchs and parameters file?")
######################################################################################
### Test config
######################################################################################
IF (ENABLE_CMAKE_TESTING OR ENABLE_MINIMAL_CMAKE_TESTING)
ENABLE_TESTING()
ENDIF (ENABLE_CMAKE_TESTING OR ENABLE_MINIMAL_CMAKE_TESTING)
######################################################################################
#######################################################################################
### Paths to EO, MO and MOEO must be specified above.
#######################################################################################
SET(EO_SRC_DIR "${CMAKE_SOURCE_DIR}/../paradiseo-eo" CACHE PATH "ParadisEO-EO source directory" FORCE)
SET(EO_BIN_DIR "${CMAKE_BINARY_DIR}/../../paradiseo-eo/build" CACHE PATH "ParadisEO-EO binary directory" FORCE)
SET(MO_SRC_DIR "${CMAKE_SOURCE_DIR}/../paradiseo-mo" CACHE PATH "ParadisMO-MO source directory" FORCE)
SET(MO_BIN_DIR "${CMAKE_BINARY_DIR}/../../paradiseo-mo/build" CACHE PATH "ParadisMO-MO binary directory" FORCE)
SET(OLDMO_SRC_DIR "${CMAKE_SOURCE_DIR}/../paradiseo-old-mo" CACHE PATH "ParadisMO-MO source directory" FORCE)
SET(OLDMO_BIN_DIR "${CMAKE_BINARY_DIR}/../../paradiseo-old-mo/build" CACHE PATH "ParadisMO-MO binary directory" FORCE)
SET(MOEO_SRC_DIR "${CMAKE_SOURCE_DIR}/../paradiseo-moeo" CACHE PATH "ParadisMOEO-MOEO source directory" FORCE)
SET(MOEO_BIN_DIR "${CMAKE_BINARY_DIR}/../../paradiseo-moeo/build" CACHE PATH "ParadisMOEO-MOEO binary directory" FORCE)
SET(PROBLEMS_SRC_DIR "${CMAKE_SOURCE_DIR}/../problems" CACHE PATH "Problems dependant source directory" FORCE)
######################################################################################
######################################################################################
### Subdirectories that CMake should process for MO, MOEO and PEO
######################################################################################
ADD_SUBDIRECTORY(doc)
ADD_SUBDIRECTORY(src)
ADD_SUBDIRECTORY(test)
ADD_SUBDIRECTORY(tutorial)
######################################################################################

88
tags/ParadisEO-GPU-1.1/paradiseo-mo/src/continuator/moAverageFitnessNeighborStat.h
View file

@ -1,88 +0,0 @@
/*
<moAverageFitnessNeighborStat.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 moAverageFitnessNeighborStat_h
#define moAverageFitnessNeighborStat_h
#include <continuator/moStat.h>
#include <continuator/moNeighborhoodStat.h>
/**
* From moNeighborhoodStat, to compute the average of fitness in the neighborhood
*/
template< class Neighbor >
class moAverageFitnessNeighborStat : public moStat<typename Neighbor::EOT, double >
{
public :
typedef typename Neighbor::EOT EOT ;
typedef typename EOT::Fitness Fitness ;
using moStat< EOT, double >::value;
/**
* Constructor
* @param _nhStat a neighborhoodStat
*/
moAverageFitnessNeighborStat(moNeighborhoodStat<Neighbor> & _nhStat):
moStat<EOT, double >(0.0, "average"), nhStat(_nhStat) {}
/**
* Set the average of fitness in the neighborhood
* @param _sol the first solution
*/
virtual void init(EOT & _sol) {
value() = nhStat.getMean();
}
/**
* Set the average of fitness in the neighborhood
* @param _sol the corresponding solution
*/
virtual void operator()(EOT & _sol) {
value() = nhStat.getMean();
}
/**
* @return the class name
*/
virtual std::string className(void) const {
return "moAverageFitnessNeighborStat";
}
private:
/** moNeighborhoodStat */
moNeighborhoodStat<Neighbor> & nhStat;
};
#endif

95
tags/ParadisEO-GPU-1.1/paradiseo-mo/src/continuator/moBestFitnessStat.h
View file

@ -1,95 +0,0 @@
/*
<moBestFitnessStat.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 moBestFitnessStat_h
#define moBestFitnessStat_h
#include <continuator/moStat.h>
/**
* The statistic which save the best solution found during the search
*/
template <class EOT>
class moBestFitnessStat : public moStat<EOT, typename EOT::Fitness>
{
public :
typedef typename EOT::Fitness Fitness;
using moStat< EOT , typename EOT::Fitness >::value;
/**
* Default Constructor
* @param _reInitSol when true the best so far is reinitialized
*/
moBestFitnessStat(bool _reInitSol = true): moStat<EOT, typename EOT::Fitness>(Fitness(), "best"), reInitSol(_reInitSol), firstTime(true) {
}
/**
* Initialization of the best solution on the first one
* @param _sol the first solution
*/
virtual void init(EOT & _sol) {
if (reInitSol)
value() = _sol.fitness();
else if (firstTime)
{
value() = _sol.fitness();
firstTime = false;
}
}
/**
* Update the best solution
* @param _sol the current solution
*/
virtual void operator()(EOT & _sol) {
if (value() < _sol.fitness())
{
value() = _sol.fitness();
}
}
/**
* @return name of the class
*/
virtual std::string className(void) const {
return "moBestFitnessStat";
}
protected:
bool reInitSol;
bool firstTime;
};
#endif

118
tags/ParadisEO-GPU-1.1/paradiseo-mo/src/continuator/moBestNoImproveContinuator.h
View file

@ -1,118 +0,0 @@
/*
<moBestNoImproveContinuator.h>
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 ue,
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".
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 _moBestNoImproveContinuator_h
#define _moBestNoImproveContinuator_h
#include <continuator/moContinuator.h>
#include <neighborhood/moNeighborhood.h>
#include <comparator/moSolComparator.h>
/**
* Stop when the best solution cannot be improved
* within a given number of iterations
*/
template< class Neighbor >
class moBestNoImproveContinuator : public moContinuator<Neighbor>
{
public:
typedef typename Neighbor::EOT EOT ;
/**
* Constructor
*
* @param _bestSol the best solution
* @param _maxNoImprove number maximum of iterations
* @param _solComparator a comparator between solutions
* @param _verbose true/false : verbose mode on/off
*/
moBestNoImproveContinuator(const EOT & _bestSol,
unsigned int _maxNoImprove,
moSolComparator<EOT>& _solComparator,
bool _verbose = true): bestSol(_bestSol), maxNoImprove(_maxNoImprove), solComparator(_solComparator), verbose(_verbose) {}
/**
* Constructor where the comparator of solutions is the default comparator
*
* @param _bestSol the best solution
* @param _maxNoImprove number maximum of iterations
* @param _verbose true/false : verbose mode on/off
*/
moBestNoImproveContinuator(const EOT & _bestSol,
unsigned int _maxNoImprove,
bool _verbose = true): bestSol(_bestSol), maxNoImprove(_maxNoImprove), solComparator(defaultSolComp), verbose(_verbose) {}
/**
* Count and test the number of non improvement of the best solution
* improvement: if the current solution is STRICTLY better than the current best solution
*
*@param _solution a solution
*@return true if counter < maxNoImprove
*/
virtual bool operator()(EOT & _solution) {
if (solComparator(_solution, bestSol) || solComparator.equals(_solution, bestSol))
cpt++;
else
cpt = 0;
bool res = (cpt < maxNoImprove);
if (!res && verbose)
std::cout << "STOP in moBestNoImproveContinuator: Reached maximum number of iterations without improvement [" << cpt << "/" << maxNoImprove << "]" << std::endl;
return res;
}
/**
* reset the counter of iteration
* @param _solution a solution
*/
virtual void init(EOT & _solution) {
cpt = 0;
}
/**
* the current number of iteration without improvement
* @return the number of iteration
*/
unsigned int value() {
return cpt ;
}
private:
const EOT & bestSol;
unsigned int maxNoImprove;
unsigned int cpt;
// comparator between solutions
moSolComparator<EOT>& solComparator;
bool verbose;
moSolComparator<EOT> defaultSolComp;
};
#endif

94
tags/ParadisEO-GPU-1.1/paradiseo-mo/src/continuator/moBestSoFarStat.h
View file

@ -1,94 +0,0 @@
/*
<moBestSoFarStat.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 moBestSoFarStat_h
#define moBestSoFarStat_h
#include <continuator/moStat.h>
/**
* The statistic which save the best solution found during the search
*/
template <class EOT>
class moBestSoFarStat : public moStat<EOT, EOT>
{
public :
using moStat< EOT , EOT >::value;
/**
* Default Constructor
* @param _reInitSol when true the best so far is reinitialized
*/
moBestSoFarStat(bool _reInitSol = true): moStat<EOT, EOT>(EOT(), "best"), reInitSol(_reInitSol), firstTime(true) {
}
/**
* Initialization of the best solution on the first one
* @param _sol the first solution
*/
virtual void init(EOT & _sol) {
if (reInitSol)
value() = _sol;
else if (firstTime)
{
value() = _sol;
firstTime = false;
}
}
/**
* Update the best solution
* @param _sol the current solution
*/
virtual void operator()(EOT & _sol) {
if (value().fitness() < _sol.fitness())
{
value() = _sol;
}
}
/**
* @return name of the class
*/
virtual std::string className(void) const {
return "moBestSoFarStat";
}
protected:
bool reInitSol;
bool firstTime;
};
#endif

82
tags/ParadisEO-GPU-1.1/paradiseo-mo/src/continuator/moBooleanStat.h
View file

@ -1,82 +0,0 @@
/*
<moBooleanStat.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 moBooleanStat_h
#define moBooleanStat_h
#include <continuator/moStat.h>
/**
* The statistic gives from a boolean variable
*/
template <class EOT>
class moBooleanStat : public moStat<EOT, bool>
{
public :
using moStat< EOT, bool>::value;
/**
* Default Constructor
*/
moBooleanStat(bool * _b): moStat<EOT, bool>(*_b, "boolean"), b(_b) {
}
/**
* Init the number of iteration
* @param _sol a solution
*/
virtual void init(EOT & _sol) {
value() = *b;
}
/**
* Set the number of iteration
* @param _sol a solution
*/
virtual void operator()(EOT & _sol) {
value() = *b;
}
/**
* @return name of the class
*/
virtual std::string className(void) const {
return "moBooleanStat";
}
private:
bool * b;
};
#endif

197
tags/ParadisEO-GPU-1.1/paradiseo-mo/src/continuator/moCheckpoint.h
View file

@ -1,197 +0,0 @@
/*
<moCheckpoint.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 moCheckpoint_h
#define moCheckpoint_h
#include <continuator/moContinuator.h>
#include <utils/eoMonitor.h>
#include <continuator/moStatBase.h>
#include <utils/eoUpdater.h>
#include <continuator/moUpdater.h>
#include <neighborhood/moNeighborhood.h>
/**
* Continuator allowing to add others (continuators, stats, monitors or updaters)
*/
template <class Neighbor>
class moCheckpoint : public moContinuator<Neighbor> {
public :
typedef typename Neighbor::EOT EOT ;
/**
* Constructor (moCheckpoint must have at least one continuator)
* @param _cont a continuator
* @param _interval frequency to compute statistical operators
*/
moCheckpoint(moContinuator<Neighbor>& _cont, unsigned int _interval=1):interval(_interval), counter(0) {
continuators.push_back(&_cont);
}
/**
* add a continuator to the checkpoint
* @param _cont a continuator
*/
void add(moContinuator<Neighbor>& _cont) {
continuators.push_back(&_cont);
}
/**
* add a statistic operator to the checkpoint
* @param _stat a statistic operator
*/
void add(moStatBase<EOT>& _stat) {
stats.push_back(&_stat);
}
/**
* add a monitor to the checkpoint
* @param _mon a monitor
*/
void add(eoMonitor& _mon) {
monitors.push_back(&_mon);
}
/**
* add a updater to the checkpoint
* @param _upd an updater
*/
void add(eoUpdater& _upd) {
updaters.push_back(&_upd);
}
/**
* add a MO updater to the checkpoint
* @param _moupd an mo updater
*/
void add(moUpdater& _moupd) {
moupdaters.push_back(&_moupd);
}
/**
* init all continuators containing in the checkpoint regarding a solution
* @param _sol the corresponding solution
*/
virtual void init(EOT& _sol) {
for (unsigned i = 0; i < stats.size(); ++i)
stats[i]->init(_sol);
counter=1;
for (unsigned i = 0; i < moupdaters.size(); ++i)
moupdaters[i]->init();
for (unsigned int i = 0; i < monitors.size(); ++i)
(*monitors[i])();
for (unsigned i = 0; i < continuators.size(); ++i)
continuators[i]->init(_sol);
}
/**
* @return class name
*/
virtual std::string className(void) const {
return "moCheckpoint";
}
/**
* apply operator of checkpoint's containers
* @param _sol reference of the solution
* @return true if all continuator return true
*/
bool operator()(EOT & _sol) {
unsigned i;
bool bContinue = true;
for (i = 0; i < stats.size(); ++i) {
if (counter % interval == 0)
(*stats[i])(_sol);
counter++;
}
for (i = 0; i < updaters.size(); ++i)
(*updaters[i])();
for (i = 0; i < moupdaters.size(); ++i)
(*moupdaters[i])();
for (i = 0; i < monitors.size(); ++i)
(*monitors[i])();
for (i = 0; i < continuators.size(); ++i)
if ( !(*continuators[i])(_sol) )
bContinue = false;
return bContinue;
}
/**
* last call of statistic operators, monitors and updaters
* @param _sol reference of the solution
*/
void lastCall(EOT& _sol) {
unsigned int i;
for (i = 0; i < stats.size(); ++i)
stats[i]->lastCall(_sol);
for (i = 0; i < updaters.size(); ++i)
updaters[i]->lastCall();
for (i = 0; i < moupdaters.size(); ++i)
moupdaters[i]->lastCall();
for (i = 0; i < monitors.size(); ++i)
monitors[i]->lastCall();
}
private :
/** continuators vector */
std::vector<moContinuator<Neighbor>*> continuators;
/** statistic operators vector */
std::vector<moStatBase<EOT>*> stats;
/** monitors vector */
std::vector<eoMonitor*> monitors;
/** updaters vector */
std::vector<eoUpdater*> updaters;
/** MO updaters vector */
std::vector<moUpdater*> moupdaters;
unsigned int interval;
unsigned int counter;
};
#endif

93
tags/ParadisEO-GPU-1.1/paradiseo-mo/src/continuator/moCombinedContinuator.h
View file

@ -1,93 +0,0 @@
/*
<moCombinedContinuator.h>
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 ue,
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".
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 _moCombinedContinuator_h
#define _moCombinedContinuator_h
#include <continuator/moContinuator.h>
#include <neighborhood/moNeighborhood.h>
#include <vector>
/**
* Combined several continuators.
* Continue until one of the continuators returns false
*/
template< class Neighbor >
class moCombinedContinuator : public moContinuator<Neighbor>
{
public:
typedef typename Neighbor::EOT EOT ;
/**
* Constructor (moCheckpoint must have at least one continuator)
* @param _cont a continuator
*/
moCombinedContinuator(moContinuator<Neighbor>& _cont) {
continuators.push_back(&_cont);
}
/**
* add a continuator to the combined continuator
* @param _cont a continuator
*/
void add(moContinuator<Neighbor>& _cont) {
continuators.push_back(&_cont);
}
/**
* init all continuators
* @param _solution a solution
*/
virtual void init(EOT & _solution) {
for (unsigned int i = 0; i < continuators.size(); ++i)
continuators[i]->init(_solution);
}
/**
*@param _solution a solution
*@return true all the continuators are true
*/
virtual bool operator()(EOT & _solution) {
bool bContinue = true;
// some data may be update in each continuator.
// So, all continuators are tested
for (unsigned int i = 0; i < continuators.size(); ++i)
if ( !(*continuators[i])(_solution) )
bContinue = false;
return bContinue;
}
private:
/** continuators vector */
std::vector< moContinuator<Neighbor>* > continuators;
};
#endif

64
tags/ParadisEO-GPU-1.1/paradiseo-mo/src/continuator/moContinuator.h
View file

@ -1,64 +0,0 @@
/*
<moContinuator.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 _moContinuator_h
#define _moContinuator_h
#include <eoFunctor.h>
#include <neighborhood/moNeighborhood.h>
/**
* To make specific continuator from a solution
*/
template< class Neighbor >
class moContinuator : public eoUF<typename Neighbor::EOT &, bool>
{
public:
typedef typename Neighbor::EOT EOT ;
/**
* Init Continuator parameters
* @param _solution the related solution
*/
virtual void init(EOT& _solution) {};
/**
* Last Call to terminate the checkpoint
* @param _solution the related solution
*/
virtual void lastCall(EOT& _solution) {};
};
#endif

97
tags/ParadisEO-GPU-1.1/paradiseo-mo/src/continuator/moCounterMonitorSaver.h
View file

@ -1,97 +0,0 @@
/*
<moCounterMonitorSaver.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 moCounterMonitorSaver_h
#define moCounterMonitorSaver_h
#include <utils/eoUpdater.h>
#include <utils/eoMonitor.h>
/**
* Class calling monitors with a given frequency
*/
class moCounterMonitorSaver : public eoUpdater {
public :
/**
* Constructor
* @param _interval frequency to call monitors
* @param _mon a monitor
*/
moCounterMonitorSaver(unsigned _interval, eoMonitor& _mon) : interval(_interval), counter(0) {
monitors.push_back(&_mon);
}
/**
* call monitors if interval is reach by a counter
*/
void operator()(void) {
if (counter++ % interval == 0)
for (unsigned i = 0; i < monitors.size(); i++)
(*monitors[i])();
}
/**
* last call of monitors
*/
void lastCall(void) {
for (unsigned i = 0; i < monitors.size(); i++)
monitors[i]->lastCall();
}
/**
* attach another monitor to this class
* @param _mon the monitor to attach
*/
void add(eoMonitor& _mon) {
monitors.push_back(&_mon);
}
/**
* @return name of the class
*/
virtual std::string className(void) const {
return "moCounterMonitorSaver";
}
private :
/** interval and counter value */
unsigned int interval, counter;
/** monitor's vector */
std::vector<eoMonitor*> monitors;
};
#endif

80
tags/ParadisEO-GPU-1.1/paradiseo-mo/src/continuator/moCounterStat.h
View file

@ -1,80 +0,0 @@
/*
<moCounterStat.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 moCounterStat_h
#define moCounterStat_h
#include <continuator/moStat.h>
/**
* The statistic gives the number of iteration
*/
template <class EOT>
class moCounterStat : public moStat<EOT, unsigned int>
{
public :
using moStat< EOT, unsigned int>::value;
/**
* Default Constructor
*/
moCounterStat(): moStat<EOT, unsigned int>(0, "counter") {
}
/**
* Init the number of iteration
* @param _sol a solution
*/
virtual void init(EOT & _sol) {
value() = 0;
}
/**
* Set the number of iteration
* @param _sol a solution
*/
virtual void operator()(EOT & _sol) {
value() = value() + 1;
}
/**
* @return name of the class
*/
virtual std::string className(void) const {
return "moCounterStat";
}
};
#endif

93
tags/ParadisEO-GPU-1.1/paradiseo-mo/src/continuator/moDistanceStat.h
View file

@ -1,93 +0,0 @@
/*
<moDistanceStat.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 moDistanceStat_h
#define moDistanceStat_h
#include <utils/eoDistance.h>
#include <continuator/moStat.h>
/**
* The statistic gives the distance to a reference solution
* The reference solution could be the global optimum, or the best knowed solution
* It allows to compute the Fitness-Distance correlation (FDC)
*/
template <class EOT, class T = double>
class moDistanceStat : public moStat<EOT, T>
{
public :
using moStat< EOT, T >::value;
/**
* Constructor
* @param _dist a distance
* @param _ref the reference solution
*/
moDistanceStat(eoDistance<EOT> & _dist, EOT & _ref): moStat<EOT, T>(0, "distance"), dist(_dist), refSolution(_ref) {}
/**
* Compute distance between the first solution and the reference solution
* @param _sol the first solution
*/
virtual void init(EOT & _sol) {
value() = dist(_sol, refSolution);
}
/**
* Compute distance between a solution and the reference solution
* @param _sol a solution
*/
virtual void operator()(EOT & _sol) {
value() = dist(_sol, refSolution);
}
/**
* @return name of the class
*/
virtual std::string className(void) const {
return "moDistanceStat";
}
private:
/** the distance */
eoDistance<EOT> & dist;
/**
* the reference solution does not change during the run
* it could be the best solution knowed of the problem
*/
EOT refSolution;
};
#endif

99
tags/ParadisEO-GPU-1.1/paradiseo-mo/src/continuator/moEvalsContinuator.h
View file

@ -1,99 +0,0 @@
/*
<moEvalsContinuator.h>
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 ue,
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".
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 _moEvalsContinuator_h
#define _moEvalsContinuator_h
#include <continuator/moContinuator.h>
#include <neighborhood/moNeighborhood.h>
#include <eoEvalFuncCounter.h>
#include <eval/moEvalCounter.h>
/**
* Continue until a maximum fixed number of full evaluation and neighbor evaluation is reached (total number of evaluation = full evaluation + incremental evaluation)
*
*
* Becareful 1: if restartCounter is true, then the number of neighbor evaluations (for example incremental evaluations) is considered during the local search (not before it)
*
* Becareful 2: Can not be used if the evaluation function is used in parallel
*
* Becareful 3: Check if the incremental does not use full evaluation, otherwise the total number of evaluations is not correct
*/
template< class Neighbor >
class moEvalsContinuator : public moContinuator<Neighbor>
{
public:
typedef typename Neighbor::EOT EOT ;
/**
* Constructor
* @param _fullEval full evaluation function to count
* @param _neighborEval neighbor evaluation function to count
* @param _maxEvals number maximum of evaluations (full and incremental evaluations)
* @param _restartCounter if true the counter of number of evaluations restarts to "zero" at initialization, if false, the number is cumulative
*/
moEvalsContinuator(eoEvalFuncCounter<EOT> & _fullEval, moEvalCounter<Neighbor> & _neighborEval, unsigned int _maxEvals, bool _restartCounter = true): fullEval(_fullEval), neighborEval(_neighborEval), maxEvals(_maxEvals), restartCounter(_restartCounter) {}
/**
* Test if continue
* @param _solution a solution
* @return true if number of evaluations < maxEvals
*/
virtual bool operator()(EOT & _solution) {
return (fullEval.value() + neighborEval.value() - nbEval_start < maxEvals);
}
/**
* Reset the number of evaluations
* @param _solution a solution
*/
virtual void init(EOT & _solution) {
if (restartCounter)
nbEval_start = fullEval.value() + neighborEval.value();
else
nbEval_start = 0;
}
/**
* the current number of evaluation from the begining
* @return the number of evaluation
*/
unsigned int value() {
return fullEval.value() + neighborEval.value() - nbEval_start ;
}
private:
eoEvalFuncCounter<EOT> & fullEval;
moEvalCounter<Neighbor> & neighborEval;
unsigned int maxEvals;
bool restartCounter;
unsigned int nbEval_start ;
};
#endif

63
tags/ParadisEO-GPU-1.1/paradiseo-mo/src/continuator/moFitContinuator.h
View file

@ -1,63 +0,0 @@
/*
<moFitContinuator.h>
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 ue,
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".
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 _moFitContinuator_h
#define _moFitContinuator_h
#include <continuator/moContinuator.h>
#include <neighborhood/moNeighborhood.h>
/**
* Continue until a maximum fitness is reached
*/
template< class Neighbor >
class moFitContinuator : public moContinuator<Neighbor>
{
public:
typedef typename Neighbor::EOT EOT ;
typedef typename EOT::Fitness Fitness ;
/**
* @param _maxFit maximum fitness to reach
*/
moFitContinuator(Fitness _maxFit): maxFit(_maxFit) {}
/**
*@param _solution a solution
*@return true if counter < maxFit
*/
virtual bool operator()(EOT & _solution) {
return (_solution.fitness() < maxFit);
}
private:
Fitness maxFit;
};
#endif

83
tags/ParadisEO-GPU-1.1/paradiseo-mo/src/continuator/moFitnessStat.h
View file

@ -1,83 +0,0 @@
/*
<moFitnessStat.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 moFitnessStat_h
#define moFitnessStat_h
#include <continuator/moStat.h>
/**
* Stat given the fitness of the current solution
*/
template <class EOT>
class moFitnessStat : public moStat<EOT, typename EOT::Fitness>
{
public :
typedef typename EOT::Fitness Fitness;
using moStat< EOT, Fitness >::value;
/**
* Constructor
* @param _description a description of the stat
*/
moFitnessStat(std::string _description = "fitness"):
moStat<EOT, Fitness>(Fitness(), _description) {}
/**
* store the initial fitness value
* @param _sol the initial solution
*/
virtual void init(EOT & _sol)
{
value() = _sol.fitness();
}
/**
* store fitness value
* @param _sol the corresponding solution
*/
virtual void operator()(EOT & _sol)
{
value() = _sol.fitness();
}
/**
* @return the name of the class
*/
virtual std::string className(void) const {
return "moFitnessStat";
}
};
#endif

96
tags/ParadisEO-GPU-1.1/paradiseo-mo/src/continuator/moFullEvalContinuator.h
View file

@ -1,96 +0,0 @@
/*
<moFullEvalContinuator.h>
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 ue,
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".
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 _moFullEvalContinuator_h
#define _moFullEvalContinuator_h
#include <continuator/moContinuator.h>
#include <neighborhood/moNeighborhood.h>
#include <eoEvalFuncCounter.h>
/**
* Continue until a maximum fixed number of full evaluation is reached
*
*
* Becareful 1: if restartCounter is true, then the number of full evaluations is considered during the local search (not before it)
*
* Becareful 2: Can not be used if the evaluation function is used in parallel
*/
template< class Neighbor >
class moFullEvalContinuator : public moContinuator<Neighbor>
{
public:
typedef typename Neighbor::EOT EOT ;
/**
* Constructor
* @param _eval evaluation function to count
* @param _maxFullEval number maximum of iterations
* @param _restartCounter if true the counter of number of evaluations restarts to "zero" at initialization, if false, the number is cumulative
*/
moFullEvalContinuator(eoEvalFuncCounter<EOT> & _eval, unsigned int _maxFullEval, bool _restartCounter = true): eval(_eval), maxFullEval(_maxFullEval), restartCounter(_restartCounter) {
nbEval_start = eval.value();
}
/**
* Test if continue
* @param _solution a solution
* @return true if number of evaluations < maxFullEval
*/
virtual bool operator()(EOT & _solution) {
return (eval.value() - nbEval_start < maxFullEval);
}
/**
* Reset the number of evaluations
* @param _solution a solution
*/
virtual void init(EOT & _solution) {
if (restartCounter)
nbEval_start = eval.value();
else
nbEval_start = 0;
}
/**
* the current number of evaluation from the begining
* @return the number of evaluation
*/
unsigned int value() {
return eval.value() - nbEval_start ;
}
private:
eoEvalFuncCounter<EOT> & eval;
unsigned int nbEval_start ;
bool restartCounter;
unsigned int maxFullEval ;
};
#endif

86
tags/ParadisEO-GPU-1.1/paradiseo-mo/src/continuator/moIterContinuator.h
View file

@ -1,86 +0,0 @@
/*
<moIterContinuator.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 ue,
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".
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 _moIterContinuator_h
#define _moIterContinuator_h
#include <continuator/moContinuator.h>
#include <neighborhood/moNeighborhood.h>
/**
* Continue until a maximum fixed number of iterations is reached
*/
template< class Neighbor >
class moIterContinuator : public moContinuator<Neighbor>
{
public:
typedef typename Neighbor::EOT EOT ;
/**
* @param _maxIter number maximum of iterations
* @param _verbose true/false : verbose mode on/off
*/
moIterContinuator(unsigned int _maxIter, bool _verbose=true): maxIter(_maxIter), verbose(_verbose) {}
/**
*@param _solution a solution
*@return true if counter < maxIter
*/
virtual bool operator()(EOT & _solution) {
bool res;
cpt++;
res = (cpt < maxIter);
if (!res && verbose)
std::cout << "STOP in moIterContinuator: Reached maximum number of iterations [" << cpt << "/" << maxIter << "]" << std::endl;
return res;
}
/**
* reset the counter of iteration
* @param _solution a solution
*/
virtual void init(EOT & _solution) {
cpt = 0;
}
/**
* the current number of iteration
* @return the number of iteration
*/
unsigned int value() {
return cpt ;
}
private:
unsigned int maxIter;
unsigned int cpt;
bool verbose;
};
#endif

89
tags/ParadisEO-GPU-1.1/paradiseo-mo/src/continuator/moMaxNeighborStat.h
View file

@ -1,89 +0,0 @@
/*
<moMaxNeighborStat.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 moMaxNeighborStat_h
#define moMaxNeighborStat_h
#include <continuator/moStat.h>
#include <continuator/moNeighborhoodStat.h>
#include <neighborhood/moNeighborhood.h>
/**
* From moNeighborhoodStat, to compute the max fitness in the neighborhood
*/
template< class Neighbor >
class moMaxNeighborStat : public moStat<typename Neighbor::EOT, typename Neighbor::EOT::Fitness>
{
public :
typedef typename Neighbor::EOT EOT ;
typedef typename EOT::Fitness Fitness ;
using moStat< EOT, Fitness >::value;
/**
* Constructor
* @param _nhStat a neighborhoodStat
*/
moMaxNeighborStat(moNeighborhoodStat<Neighbor> & _nhStat):
moStat<EOT, Fitness>(Fitness(), "min"), nhStat(_nhStat) {}
/**
* Set the max fitness in the neighborhood
* @param _sol the first solution
*/
virtual void init(EOT & _sol) {
value() = nhStat.getMax();
}
/**
* Set the max fitness in the neighborhood
* @param _sol the corresponding solution
*/
virtual void operator()(EOT & _sol) {
value() = nhStat.getMax();
}
/**
* @return the class name
*/
virtual std::string className(void) const {
return "moMaxNeighborStat";
}
private:
/** moNeighborhoodStat */
moNeighborhoodStat<Neighbor> & nhStat;
};
#endif

89
tags/ParadisEO-GPU-1.1/paradiseo-mo/src/continuator/moMinNeighborStat.h
View file

@ -1,89 +0,0 @@
/*
<moMinNeighborStat.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 moMinNeighborStat_h
#define moMinNeighborStat_h
#include <continuator/moStat.h>
#include <continuator/moNeighborhoodStat.h>
#include <neighborhood/moNeighborhood.h>
/**
* From moNeighborhoodStat, to compute the min fitness in the neighborhood
*/
template< class Neighbor >
class moMinNeighborStat : public moStat<typename Neighbor::EOT, typename Neighbor::EOT::Fitness>
{
public :
typedef typename Neighbor::EOT EOT ;
typedef typename EOT::Fitness Fitness ;
using moStat< EOT, Fitness >::value;
/**
* Constructor
* @param _nhStat a neighborhoodStat
*/
moMinNeighborStat(moNeighborhoodStat<Neighbor> & _nhStat):
moStat<EOT, Fitness>(Fitness(), "min"), nhStat(_nhStat) {}
/**
* Set the worst fitness in the neighborhood
* @param _sol the first solution
*/
virtual void init(EOT & _sol) {
value() = nhStat.getMin();
}
/**
* Set the worst fitness in the neighborhood
* @param _sol the corresponding solution
*/
virtual void operator()(EOT & _sol) {
value() = nhStat.getMin();
}
/**
* @return the class name
*/
virtual std::string className(void) const {
return "moMinNeighborStat";
}
private:
/** moNeighborhoodStat */
moNeighborhoodStat<Neighbor> & nhStat;
};
#endif

90
tags/ParadisEO-GPU-1.1/paradiseo-mo/src/continuator/moMinusOneCounterStat.h
View file

@ -1,90 +0,0 @@
/*
<moMinusOneCounterStat.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 moMinusOneCounterStat_h
#define moMinusOneCounterStat_h
#include <continuator/moStat.h>
/**
* The statistic gives the number of iteration minus 1
* then the last iteration is not counted (for example for length of adaptive walk)
*/
template <class EOT>
class moMinusOneCounterStat : public moStat<EOT, unsigned int>
{
public :
using moStat< EOT, unsigned int>::value;
/**
* Default Constructor
*/
moMinusOneCounterStat(): moStat<EOT, unsigned int>(0, "counter") {
counter = 0;
}
/**
* Init the number of iteration
* @param _sol a solution
*/
virtual void init(EOT & _sol) {
counter = 0;
value() = 0;
}
/**
* Set the number of iteration
* @param _sol a solution
*/
virtual void operator()(EOT & _sol) {
counter++;
if (counter > 0)
value() = counter - 1;
else
value() = 0;
}
/**
* @return name of the class
*/
virtual std::string className(void) const {
return "moMinusOneCounterStat";
}
private:
unsigned int counter;
};
#endif

90
tags/ParadisEO-GPU-1.1/paradiseo-mo/src/continuator/moNbInfNeighborStat.h
View file

@ -1,90 +0,0 @@
/*
<moNbInfNeighborStat.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 moNbInfNeighborStat_h
#define moNbInfNeighborStat_h
#include <continuator/moStat.h>
#include <continuator/moNeighborhoodStat.h>
#include <neighborhood/moNeighborhood.h>
/**
* From moNeighborhoodStat, to compute the number of solutions in the neighborhood
* with (strictly) lower fitness than the current solution
*/
template< class Neighbor >
class moNbInfNeighborStat : public moStat<typename Neighbor::EOT, unsigned>
{
public :
typedef typename Neighbor::EOT EOT ;
typedef typename EOT::Fitness Fitness ;
using moStat< EOT, unsigned >::value;
/**
* Constructor
* @param _nhStat a neighborhoodStat
*/
moNbInfNeighborStat(moNeighborhoodStat<Neighbor> & _nhStat):
moStat<EOT, unsigned>(0, "nb inf"), nhStat(_nhStat) {}
/**
* Set the number of solutions in the neighborhood with (strictly) lower fitness than the current solution
* @param _sol the first solution
*/
virtual void init(EOT & _sol) {
value() = nhStat.getNbInf();
}
/**
* Set the number of solutions in the neighborhood with (strictly) lower fitness than the current solution
* @param _sol the corresponding solution
*/
virtual void operator()(EOT & _sol) {
value() = nhStat.getNbInf();
}
/**
* @return the class name
*/
virtual std::string className(void) const {
return "moNbInfNeighborStat";
}
private:
/** moNeighborhoodStat */
moNeighborhoodStat<Neighbor> & nhStat;
};
#endif

90
tags/ParadisEO-GPU-1.1/paradiseo-mo/src/continuator/moNbSupNeighborStat.h
View file

@ -1,90 +0,0 @@
/*
<moNbSupNeighborStat.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 moNbSupNeighborStat_h
#define moNbSupNeighborStat_h
#include <continuator/moStat.h>
#include <continuator/moNeighborhoodStat.h>
#include <neighborhood/moNeighborhood.h>
/**
* From moNeighborhoodStat, to compute the number of solutions in the neighborhood
* with higher fitness than the current solution
*/
template< class Neighbor >
class moNbSupNeighborStat : public moStat<typename Neighbor::EOT, unsigned>
{
public :
typedef typename Neighbor::EOT EOT ;
typedef typename EOT::Fitness Fitness ;
using moStat< EOT, unsigned >::value;
/**
* Constructor
* @param _nhStat a neighborhoodStat
*/
moNbSupNeighborStat(moNeighborhoodStat<Neighbor> & _nhStat):
moStat<EOT, unsigned>(0, "nb sup"), nhStat(_nhStat) {}
/**
* Set the number of solutions in the neighborhood with better fitness than the current solution
* @param _sol the first solution
*/
virtual void init(EOT & _sol) {
value() = nhStat.getNbSup();
}
/**
* Set the number of solutions in the neighborhood with better fitness than the current solution
* @param _sol the corresponding solution
*/
virtual void operator()(EOT & _sol) {
value() = nhStat.getNbSup();
}
/**
* @return the class name
*/
virtual std::string className(void) const {
return "moNbSupNeighborStat";
}
private:
/** moNeighborhoodStat */
moNeighborhoodStat<Neighbor> & nhStat;
};
#endif

167
tags/ParadisEO-GPU-1.1/paradiseo-mo/src/continuator/moNeighborBestStat.h
View file

@ -1,167 +0,0 @@
/*
<moNeighborBestStat.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 moNeighborBestStat_h
#define moNeighborBestStat_h
#include <continuator/moStat.h>
#include <explorer/moNeighborhoodExplorer.h>
#include <comparator/moNeighborComparator.h>
#include <comparator/moSolNeighborComparator.h>
#include <neighborhood/moNeighborhood.h>
/**
* Compute the fitness of the best solution among k neighbor or all neighbors
*/
template< class Neighbor >
class moNeighborBestStat : public moStat<typename Neighbor::EOT, typename Neighbor::EOT::Fitness>
{
public :
typedef typename Neighbor::EOT EOT ;
typedef moNeighborhood<Neighbor> Neighborhood ;
typedef typename EOT::Fitness Fitness ;
using moStat< EOT, Fitness >::value;
/**
* Constructor
* @param _neighborhood a neighborhood
* @param _eval an evaluation function
* @param _neighborComparator a neighbor Comparator
* @param _solNeighborComparator a comparator between a solution and a neighbor
* @param _k number of neighbors visited
*/
moNeighborBestStat(Neighborhood& _neighborhood, moEval<Neighbor>& _eval, moNeighborComparator<Neighbor>& _neighborComparator, moSolNeighborComparator<Neighbor>& _solNeighborComparator, unsigned int _k = 0):
moStat<EOT, Fitness>(true, "neighborhood"),
neighborhood(_neighborhood), eval(_eval),
neighborComparator(_neighborComparator),
solNeighborComparator(_solNeighborComparator),
kmax(_k)
{}
/**
* Default Constructor
* where the comparators are basic, there only compare the fitness values
*
* @param _neighborhood a neighborhood
* @param _eval an evaluation function
* @param _k number of neighbors visited (default all)
*/
moNeighborBestStat(Neighborhood& _neighborhood, moEval<Neighbor>& _eval, unsigned _k = 0):
moStat<EOT, Fitness>(Fitness(), "best"),
neighborhood(_neighborhood), eval(_eval),
neighborComparator(defaultNeighborComp),
solNeighborComparator(defaultSolNeighborComp),
kmax(_k)
{}
/**
* Compute classical statistics of the first solution's neighborhood
* @param _solution the first solution
*/
virtual void init(EOT & _solution) {
operator()(_solution);
}
/**
* Compute the best fitness amoung all neighbors or k neighbors
* @param _solution the corresponding solution
*/
virtual void operator()(EOT & _solution) {
Neighbor current ;
Neighbor best ;
if (neighborhood.hasNeighbor(_solution)) {
//init the first neighbor
neighborhood.init(_solution, current);
//eval the _solution moved with the neighbor and stock the result in the neighbor
eval(_solution, current);
//initialize the best neighbor
best = current;
// number of visited neighbors
unsigned int k = 1;
//test all others neighbors
while ( ( (kmax == 0) || (k < kmax) ) && neighborhood.cont(_solution)) {
//next neighbor
neighborhood.next(_solution, current);
//eval
eval(_solution, current);
//if we found a better neighbor, update the best
if (neighborComparator(best, current))
best = current;
k++;
}
value() = best.fitness();
}
else {
//if _solution hasn't neighbor,
value() = Fitness();
}
}
/**
* @return the class name
*/
virtual std::string className(void) const {
return "moNeighborBestStat";
}
private:
// to explore the neighborhood
Neighborhood& neighborhood ;
moEval<Neighbor>& eval;
// comparator betwenn solution and neighbor or between neighbors
moNeighborComparator<Neighbor>& neighborComparator;
moSolNeighborComparator<Neighbor>& solNeighborComparator;
// default comparators
// compare the fitness values of neighbors
moNeighborComparator<Neighbor> defaultNeighborComp;
// compare the fitness values of the solution and the neighbor
moSolNeighborComparator<Neighbor> defaultSolNeighborComp;
// number of neighbor to explore
unsigned int kmax;
};
#endif

94
tags/ParadisEO-GPU-1.1/paradiseo-mo/src/continuator/moNeighborEvalContinuator.h
View file

@ -1,94 +0,0 @@
/*
<moNeighborEvalContinuator.h>
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 ue,
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".
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 _moNeighborEvalContinuator_h
#define _moNeighborEvalContinuator_h
#include <continuator/moContinuator.h>
#include <neighborhood/moNeighborhood.h>
#include <eval/moEvalCounter.h>
/**
* Continue until a maximum fixed number of neighbor evaluation is reached
*
*
* Becareful 1: if restartCounter is true, then the number of neighbor evaluations (for example incremental evaluations) is considered during the local search (not before it)
*
* Becareful 2: Can not be used if the evaluation function is used in parallel
*/
template< class Neighbor >
class moNeighborEvalContinuator : public moContinuator<Neighbor>
{
public:
typedef typename Neighbor::EOT EOT ;
/**
* Constructor
* @param _eval neighbor evaluation function to count
* @param _maxNeighborEval number maximum of iterations
* @param _restartCounter if true the counter of number of evaluations restarts to "zero" at initialization, if false, the number is cumulative
*/
moNeighborEvalContinuator(moEvalCounter<Neighbor> & _eval, unsigned int _maxNeighborEval, bool _restartCounter = true): eval(_eval), maxNeighborEval(_maxNeighborEval), restartCounter(_restartCounter) {}
/**
* Test if continue
* @param _solution a solution
* @return true if number of evaluations < maxNeighborEval
*/
virtual bool operator()(EOT & _solution) {
return (eval.value() - nbEval_start < maxNeighborEval);
}
/**
* Reset the number of evaluations
* @param _solution a solution
*/
virtual void init(EOT & _solution) {
if (restartCounter)
nbEval_start = eval.value();
else
nbEval_start = 0;
}
/**
* the current number of evaluation from the begining
* @return the number of evaluation
*/
unsigned int value() {
return eval.value() - nbEval_start ;
}
private:
moEvalCounter<Neighbor> & eval;
unsigned int maxNeighborEval;
bool restartCounter;
unsigned int nbEval_start ;
};
#endif

113
tags/ParadisEO-GPU-1.1/paradiseo-mo/src/continuator/moNeighborFitnessStat.h
View file

@ -1,113 +0,0 @@
/*
<moNeighborFitnessStat.h>
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 moNeighborFitnessStat_h
#define moNeighborFitnessStat_h
#include <continuator/moStat.h>
#include <neighborhood/moNeighborhood.h>
#include <eval/moEval.h>
/**
* Compute the fitness of one random neighbor
*/
template< class Neighbor >
class moNeighborFitnessStat : public moStat<typename Neighbor::EOT, typename Neighbor::EOT::Fitness>
{
public :
typedef typename Neighbor::EOT EOT ;
typedef moNeighborhood<Neighbor> Neighborhood ;
typedef typename EOT::Fitness Fitness ;
using moStat< EOT, Fitness >::value;
/**
* Constructor
* @param _neighborhood a neighborhood
* @param _eval an evaluation function
*/
moNeighborFitnessStat(Neighborhood& _neighborhood, moEval<Neighbor>& _eval):
moStat<EOT, Fitness>(Fitness(), "neighborhood"),
neighborhood(_neighborhood), eval(_eval)
{
if (!neighborhood.isRandom()) {
std::cout << "moNeighborFitnessStat::Warning -> the neighborhood used is not random, the neighbor will not be random" << std::endl;
}
}
/**
* Compute the fitness of one random neighbor
* @param _solution the first solution
*/
virtual void init(EOT & _solution) {
operator()(_solution);
}
/**
* Compute the fitness of one random neighbor
* @param _solution the corresponding solution
*/
virtual void operator()(EOT & _solution) {
if (neighborhood.hasNeighbor(_solution)) {
Neighbor current ;
//init the first neighbor which is supposed to be random
neighborhood.init(_solution, current);
//eval the _solution moved with the neighbor and stock the result in the neighbor
eval(_solution, current);
// the fitness value is collected
value() = current.fitness();
} else {
//if _solution hasn't neighbor,
value() = Fitness();
}
}
/**
* @return the class name
*/
virtual std::string className(void) const {
return "moNeighborFitnessStat";
}
private:
// the neighborhood
Neighborhood& neighborhood ;
moEval<Neighbor>& eval;
};
#endif

264
tags/ParadisEO-GPU-1.1/paradiseo-mo/src/continuator/moNeighborhoodStat.h
View file

@ -1,264 +0,0 @@
/*
<moNeighborhoodStat.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 moNeighborhoodStat_h
#define moNeighborhoodStat_h
#include <continuator/moStat.h>
#include <explorer/moNeighborhoodExplorer.h>
#include <comparator/moNeighborComparator.h>
#include <comparator/moSolNeighborComparator.h>
#include <neighborhood/moNeighborhood.h>
/**
* All possible statitic on the neighborhood fitness
* to combine with other specific statistic to print them
*/
template< class Neighbor >
class moNeighborhoodStat : public moStat<typename Neighbor::EOT, bool>
{
public :
typedef typename Neighbor::EOT EOT ;
typedef moNeighborhood<Neighbor> Neighborhood ;
typedef typename EOT::Fitness Fitness ;
using moStat< EOT, bool >::value;
/**
* Constructor
* @param _neighborhood a neighborhood
* @param _eval an evaluation function
* @param _neighborComparator a neighbor Comparator
* @param _solNeighborComparator a comparator between a solution and a neighbor
*/
moNeighborhoodStat(Neighborhood& _neighborhood, moEval<Neighbor>& _eval, moNeighborComparator<Neighbor>& _neighborComparator, moSolNeighborComparator<Neighbor>& _solNeighborComparator):
moStat<EOT, bool>(true, "neighborhood"),
neighborhood(_neighborhood), eval(_eval),
neighborComparator(_neighborComparator),
solNeighborComparator(_solNeighborComparator)
{}
/**
* Default Constructor
* where the comparators are basic, there only compare the fitness values
*
* @param _neighborhood a neighborhood
* @param _eval an evaluation function
*/
moNeighborhoodStat(Neighborhood& _neighborhood, moEval<Neighbor>& _eval):
moStat<EOT, bool>(true, "neighborhood"),
neighborhood(_neighborhood), eval(_eval),
neighborComparator(defaultNeighborComp),
solNeighborComparator(defaultSolNeighborComp)
{}
/**
* Compute classical statistics of the first solution's neighborhood
* @param _solution the first solution
*/
virtual void init(EOT & _solution) {
operator()(_solution);
}
/**
* Compute classical statistics of a solution's neighborhood
* @param _solution the corresponding solution
*/
virtual void operator()(EOT & _solution) {
Neighbor current ;
Neighbor best ;
Neighbor lowest ;
if (neighborhood.hasNeighbor(_solution)) {
//init the first neighbor
neighborhood.init(_solution, current);
//eval the _solution moved with the neighbor and stock the result in the neighbor
eval(_solution, current);
// init the statistics
value() = true;
mean = current.fitness();
sd = mean * mean;
nb = 1;
nbInf = 0;
nbEqual = 0;
nbSup = 0;
if (solNeighborComparator.equals(_solution, current))
nbEqual++;
else if (solNeighborComparator(_solution, current))
nbSup++;
else
nbInf++;
//initialize the best neighbor
best = current;
lowest = current;
//test all others neighbors
while (neighborhood.cont(_solution)) {
//next neighbor
neighborhood.next(_solution, current);
//eval
eval(_solution, current);
mean += current.fitness();
sd += current.fitness() * current.fitness();
nb++;
if (solNeighborComparator.equals(_solution, current))
nbEqual++;
else if (solNeighborComparator(_solution, current))
nbSup++;
else
nbInf++;
//if we found a better neighbor, update the best
if (neighborComparator(best, current))
best = current;
if (neighborComparator(current, lowest))
lowest = current;
}
max = best.fitness();
min = lowest.fitness();
mean /= nb;
if (nb > 1)
sd = sqrt( (sd - nb * mean * mean) / (nb - 1.0) );
else
sd = 0.0;
}
else {
//if _solution hasn't neighbor,
value() = false;
}
}
/**
* @return the worst fitness value found in the neighborhood
*/
Fitness getMin() {
return min;
}
/**
* @return the best fitness value found in the neighborhood
*/
Fitness getMax() {
return max;
}
/**
* @return the mean fitness value of the neighborhood
*/
double getMean() {
return mean;
}
/**
* @return the standard deviation value of the neighborhood
*/
double getSD() {
return sd;
}
/**
* @return the size of the neighborhood
*/
unsigned getSize() {
return nb;
}
/**
* @return the number of neighbors having a better fitness than the current solution
*/
unsigned getNbSup() {
return nbSup;
}
/**
* @return the number of neighbors having the same fitness than the current solution
*/
unsigned getNbEqual() {
return nbEqual;
}
/**
* @return the number of neighbors having a worst fitness than the current solution
*/
unsigned getNbInf() {
return nbInf;
}
/**
* @return the class name
*/
virtual std::string className(void) const {
return "moNeighborhoodStat";
}
protected:
//the neighborhood
Neighborhood& neighborhood ;
moEval<Neighbor>& eval;
// comparator betwenn solution and neighbor or between neighbors
moNeighborComparator<Neighbor>& neighborComparator;
moSolNeighborComparator<Neighbor>& solNeighborComparator;
// default comparators
// compare the fitness values of neighbors
moNeighborComparator<Neighbor> defaultNeighborComp;
// compare the fitness values of the solution and the neighbor
moSolNeighborComparator<Neighbor> defaultSolNeighborComp;
// the stastics of the fitness
Fitness max, min;
//mean and standard deviation
double mean, sd ;
// number of neighbors in the neighborhood;
unsigned int nb;
// number of neighbors with lower, equal and higher fitness
unsigned int nbInf, nbEqual, nbSup ;
};
#endif

90
tags/ParadisEO-GPU-1.1/paradiseo-mo/src/continuator/moNeutralDegreeNeighborStat.h
View file

@ -1,90 +0,0 @@
/*
<moNeutralDegreeNeighborStat.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 moNeutralDegreeNeighborStat_h
#define moNeutralDegreeNeighborStat_h
#include <continuator/moStat.h>
#include <continuator/moNeighborhoodStat.h>
/**
* From moNeighborhoodStat, to compute the neutral degree of the solution
* which is the number of solutions in the neighborhood
* with equals fitness
*/
template< class Neighbor >
class moNeutralDegreeNeighborStat : public moStat<typename Neighbor::EOT, unsigned>
{
public :
typedef typename Neighbor::EOT EOT ;
typedef typename EOT::Fitness Fitness ;
using moStat< EOT, unsigned >::value;
/**
* Constructor
* @param _nhStat a neighborhoodStat
*/
moNeutralDegreeNeighborStat(moNeighborhoodStat<Neighbor> & _nhStat):
moStat<EOT, unsigned>(0, "neutral degree"), nhStat(_nhStat) {}
/**
* Set the neutral degree of the solution which is the number of solutions in the neighborhood with equals fitness
* @param _sol the first solution
*/
virtual void init(EOT & _sol) {
value() = nhStat.getNbEqual();
}
/**
* Set the neutral degree of the solution which is the number of solutions in the neighborhood with equals fitness
* @param _sol the corresponding solution
*/
virtual void operator()(EOT & _sol) {
value() = nhStat.getNbEqual();
}
/**
* @return the class name
*/
virtual std::string className(void) const {
return "moNeutralDegreeNeighborStat";
}
private:
/** moNeighborhoodStat */
moNeighborhoodStat<Neighbor> & nhStat;
};
#endif

90
tags/ParadisEO-GPU-1.1/paradiseo-mo/src/continuator/moSecondMomentNeighborStat.h
View file

@ -1,90 +0,0 @@
/*
<moSecondMomentNeighborStat.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 moSecondMomentNeighborStat_h
#define moSecondMomentNeighborStat_h
#include <continuator/moStat.h>
#include <continuator/moNeighborhoodStat.h>
/**
* From moNeighborhoodStat, to compute the average and the standard deviation of fitness in the neighborhood
*/
template< class Neighbor >
class moSecondMomentNeighborStat : public moStat<typename Neighbor::EOT, std::pair<double, double> >
{
public :
typedef typename Neighbor::EOT EOT ;
typedef typename EOT::Fitness Fitness ;
using moStat< EOT, std::pair<double, double> >::value;
/**
* Constructor
* @param _nhStat a neighborhoodStat
*/
moSecondMomentNeighborStat(moNeighborhoodStat<Neighbor> & _nhStat):
moStat<EOT, std::pair<double, double> >(std::make_pair(0.0,0.0), "average and stdev"), nhStat(_nhStat) {}
/**
* Set the average and the standard deviation of fitness in the neighborhood
* @param _sol the first solution
*/
virtual void init(EOT & _sol) {
value().first = nhStat.getMean();
value().second = nhStat.getSD();
}
/**
* Set the average and the standard deviation of fitness in the neighborhood
* @param _sol the corresponding solution
*/
virtual void operator()(EOT & _sol) {
value().first = nhStat.getMean();
value().second = nhStat.getSD();
}
/**
* @return the class name
*/
virtual std::string className(void) const {
return "moSecondMomentNeighborStat";
}
private:
/** moNeighborhoodStat */
moNeighborhoodStat<Neighbor> & nhStat;
};
#endif

89
tags/ParadisEO-GPU-1.1/paradiseo-mo/src/continuator/moSizeNeighborStat.h
View file

@ -1,89 +0,0 @@
/*
<moSizeNeighborStat.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 moSizeNeighborStat_h
#define moSizeNeighborStat_h
#include <continuator/moStat.h>
#include <continuator/moNeighborhoodStat.h>
/**
* From moNeighborhoodStat, to compute the number of solutions in the neighborhood
*
*/
template< class Neighbor >
class moSizeNeighborStat : public moStat<typename Neighbor::EOT, unsigned>
{
public :
typedef typename Neighbor::EOT EOT ;
typedef typename EOT::Fitness Fitness ;
using moStat< EOT, unsigned >::value;
/**
* Constructor
* @param _nhStat a neighborhoodStat
*/
moSizeNeighborStat(moNeighborhoodStat<Neighbor> & _nhStat):
moStat<EOT, unsigned>(0, "size"), nhStat(_nhStat) {}
/**
* Set the number of solutions in the neighborhood
* @param _sol the first solution
*/
virtual void init(EOT & _sol) {
value() = nhStat.getSize();
}
/**
* Set the number of solutions in the neighborhood
* @param _sol the corresponding solution
*/
virtual void operator()(EOT & _sol) {
value() = nhStat.getSize();
}
/**
* @return the class name
*/
virtual std::string className(void) const {
return "moSizeNeighborStat";
}
private:
/** moNeighborhoodStat */
moNeighborhoodStat<Neighbor> & nhStat;
};
#endif

82
tags/ParadisEO-GPU-1.1/paradiseo-mo/src/continuator/moSolutionStat.h
View file

@ -1,82 +0,0 @@
/*
<moSolutionStat.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 moSolutionStat_h
#define moSolutionStat_h
#include <continuator/moStat.h>
/**
* The statistic which only give the current solution.
* Be careful, the solution is given by copy
*
*/
template <class EOT>
class moSolutionStat : public moStat<EOT, EOT>
{
public :
using moStat< EOT, EOT >::value;
/**
* Constructor
* @param _description a description of the parameter
*/
moSolutionStat(std::string _description = "solution"):
moStat<EOT, EOT>(EOT(), _description) { }
/**
* Initialization the solution by copy
* @param _sol the intial solution
*/
virtual void init(EOT & _sol) {
value() = _sol;
}
/**
* Set the solution by copy
* @param _sol the corresponding solution
*/
virtual void operator()(EOT & _sol) {
value() = _sol;
}
/**
* @return name of the class
*/
virtual std::string className(void) const {
return "moSolutionStat";
}
};
#endif

61
tags/ParadisEO-GPU-1.1/paradiseo-mo/src/continuator/moStat.h
View file

@ -1,61 +0,0 @@
/*
<moStat.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 moStat_h
#define moStat_h
#include <continuator/moStatBase.h>
/**
* The actual class that will be used as base for all statistics
* that need to be calculated over the solution
* It is a moStatBase AND an eoValueParam so it can be used in Monitors.
*/
template <class EOT, class T>
class moStat : public eoValueParam<T>, public moStatBase<EOT>
{
public:
/**
* Constructor
* @param _value a default parameter's value
* @param _description a description of the parameter
*/
moStat(T _value, std::string _description):
eoValueParam<T>(_value, _description) {}
};
#endif

61
tags/ParadisEO-GPU-1.1/paradiseo-mo/src/continuator/moStatBase.h
View file

@ -1,61 +0,0 @@
/*
<moStatBase.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 moStatBase_h
#define moStatBase_h
#include <eoFunctor.h>
#include <utils/eoParam.h>
/**
* Base class for all statistics that need to be calculated
* over the solution
*/
template <class EOT>
class moStatBase : public eoUF<EOT &, void>
{
public:
/**
* last call of a statistical operator
*/
virtual void lastCall(EOT &) {}
/**
* first call of a statistical operator
*/
virtual void init(EOT &) {}
};
#endif

83
tags/ParadisEO-GPU-1.1/paradiseo-mo/src/continuator/moStatFromStat.h
View file

@ -1,83 +0,0 @@
/*
<moStatFromStat.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 moStatFromStat_h
#define moStatFromStat_h
#include <continuator/moStat.h>
/**
* The statistic which copy another statistic
*/
template <class EOT, class T>
class moStatFromStat : public moStat<EOT, T>
{
public :
using moStat< EOT , T >::value;
/**
* Constructor
* @param _stat a stat
*/
moStatFromStat(moStat<EOT,T> & _stat): moStat<EOT, T>(0, _stat.description()), stat(_stat) {
}
/**
* The value of this stat is a copy of the value of the initial stat
* @param _sol a solution
*/
virtual void init(EOT & _sol) {
value() = stat.value();
}
/**
* The value of this stat is a copy of the value of the initial stat
* @param _sol a solution
*/
virtual void operator()(EOT & _sol) {
value() = stat.value();
}
/**
* @return name of the class
*/
virtual std::string className(void) const {
return "moStatFromStat";
}
private:
moStat<EOT, T> & stat;
};
#endif

88
tags/ParadisEO-GPU-1.1/paradiseo-mo/src/continuator/moStdFitnessNeighborStat.h
View file

@ -1,88 +0,0 @@
/*
<moStdFitnessNeighborStat.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 moStdFitnessNeighborStat_h
#define moStdFitnessNeighborStat_h
#include <continuator/moStat.h>
#include <continuator/moNeighborhoodStat.h>
/**
* From moNeighborhoodStat, to compute the average and the standard deviation of fitness in the neighborhood
*/
template< class Neighbor >
class moStdFitnessNeighborStat : public moStat<typename Neighbor::EOT, double >
{
public :
typedef typename Neighbor::EOT EOT ;
typedef typename EOT::Fitness Fitness ;
using moStat< EOT, double >::value;
/**
* Constructor
* @param _nhStat a neighborhoodStat
*/
moStdFitnessNeighborStat(moNeighborhoodStat<Neighbor> & _nhStat):
moStat<EOT, double >(0.0, "stdev"), nhStat(_nhStat) {}
/**
* Set the average and the standard deviation of fitness in the neighborhood
* @param _sol the first solution
*/
virtual void init(EOT & _sol) {
value() = nhStat.getSD();
}
/**
* Set the average and the standard deviation of fitness in the neighborhood
* @param _sol the corresponding solution
*/
virtual void operator()(EOT & _sol) {
value() = nhStat.getSD();
}
/**
* @return the class name
*/
virtual std::string className(void) const {
return "moStdFitnessNeighborStat";
}
private:
/** moNeighborhoodStat */
moNeighborhoodStat<Neighbor> & nhStat;
};
#endif

131
tags/ParadisEO-GPU-1.1/paradiseo-mo/src/continuator/moTimeContinuator.h
View file

@ -1,131 +0,0 @@
/*
<moTimeContinuator.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 ue,
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".
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 _moTimeContinuator_h
#define _moTimeContinuator_h
#include <continuator/moContinuator.h>
/**
* Termination condition until a running time is reached.
*/
template < class Neighbor >
class moTimeContinuator: public moContinuator<Neighbor>
{
public:
typedef typename Neighbor::EOT EOT;
/**
* Constructor
* @param _max maximum running time
* @param _verbose verbose mode true/false -> on/off
*/
moTimeContinuator(time_t _max, bool _verbose = true): max(_max), verbose(_verbose) {
external = false;
start = time(NULL);
}
/**
* Synchronize the whole time with an external starting time
* @param _externalStart external starting time
*/
virtual void setStartingTime(time_t _externalStart) {
external = true;
start = _externalStart;
}
/**
* To get the starting time
* @return starting time
*/
virtual time_t getStartingTime() {
return start;
}
/**
* To set the maximum running time
*
* @param _maxTime maximum running time
*/
virtual void maxTime(time_t _maxTime) {
max = _maxTime;
}
/**
* Returns false when the running time is reached.
* @param _sol the current solution
*/
virtual bool operator() (EOT& _sol)
{
bool res;
time_t elapsed = (time_t) difftime(time(NULL), start);
res = (elapsed < max);
if (!res && verbose)
std::cout << "STOP in moTimeContinuator: Reached maximum time [" << elapsed << "/" << max << "]" << std::endl;
return res;
}
/**
* reset the start time
* @param _solution a solution
*/
virtual void init(EOT & _solution) {
if (!external)
start = time(NULL);
}
/**
* Class name
*/
virtual std::string className(void) const
{
return "moTimeContinuator";
}
private:
/** maximum running time */
time_t max;
/** starting time */
time_t start;
/** external start flag */
bool external;
/** verbose mode */
bool verbose;
};
#endif

68
tags/ParadisEO-GPU-1.1/paradiseo-mo/src/continuator/moTrueContinuator.h
View file

@ -1,68 +0,0 @@
/*
<moTrueContinuator.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 _moTrueContinuator_h
#define _moTrueContinuator_h
#include <continuator/moContinuator.h>
/**
* Continuator always return True
*/
template< class Neighbor >
class moTrueContinuator : public moContinuator<Neighbor>
{
public:
typedef typename Neighbor::EOT EOT ;
// empty constructor
moTrueContinuator() {} ;
/**
* @param _solution a solution
* @return always true
*/
virtual bool operator()(EOT & _solution) {
return true;
}
/**
* NOTHING TO DO
* @param _solution a solution
*/
virtual void init(EOT & _solution) {}
};
#endif

82
tags/ParadisEO-GPU-1.1/paradiseo-mo/src/continuator/moUnsignedStat.h
View file

@ -1,82 +0,0 @@
/*
<moUnsignedStat.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 moUnsignedStat_h
#define moUnsignedStat_h
#include <continuator/moStat.h>
/**
* The statistic gives from a boolean variable
*/
template <class EOT>
class moUnsignedStat : public moStat<EOT, unsigned int>
{
public :
using moStat< EOT, unsigned int>::value;
/**
* Default Constructor
*/
moUnsignedStat(unsigned int * _b): moStat<EOT, unsigned int>(*_b, "unsigned"), b(_b) {
}
/**
* Init the number of iteration
* @param _sol a solution
*/
virtual void init(EOT & _sol) {
value() = *b;
}
/**
* Set the number of iteration
* @param _sol a solution
*/
virtual void operator()(EOT & _sol) {
value() = *b;
}
/**
* @return name of the class
*/
virtual std::string className(void) const {
return "moUnsignedStat";
}
private:
unsigned int * b;
};
#endif

67
tags/ParadisEO-GPU-1.1/paradiseo-mo/src/continuator/moUpdater.h
View file

@ -1,67 +0,0 @@
/*
<moUpdater.h>
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 moUpdater_h
#define moUpdater_h
#include <eoFunctor.h>
#include <utils/eoParam.h>
/**
* Base class for to update what ever you want
* similar to eoUpdater
* But there is an init method !
*/
class moUpdater : public eoF<void>
{
public:
/**
* first call of the updater
*/
virtual void init() {}
/**
* last call of the updater
*/
virtual void lastCall() {}
/**
* class name
*/
virtual std::string className(void) const
{ return "moUpdater"; }
};
#endif

84
tags/ParadisEO-GPU-1.1/paradiseo-mo/src/continuator/moValueStat.h
View file

@ -1,84 +0,0 @@
/*
<moValueStat.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 moValueStat_h
#define moValueStat_h
#include <continuator/moStat.h>
#include <utils/eoParam.h>
/**
* The statistic gives the number of iteration
*/
template <class EOT, class ValueType>
class moValueStat : public moStat<EOT, double>
{
public :
using moStat< EOT, double>::value;
/**
* Default Constructor
*/
moValueStat(eoValueParam<ValueType> & _valueParam): moStat<EOT, double>(0, "value"), valueParam(_valueParam) {
}
/**
* Init the number of iteration
* @param _sol a solution
*/
virtual void init(EOT & _sol) {
value() = (double) valueParam.value();
}
/**
* Set the number of iteration
* @param _sol a solution
*/
virtual void operator()(EOT & _sol) {
value() = (double) valueParam.value() ;
}
/**
* @return name of the class
*/
virtual std::string className(void) const {
return "moValueStat";
}
private:
eoValueParam<ValueType> & valueParam;
};
#endif

241
tags/ParadisEO-GPU-1.1/paradiseo-mo/src/continuator/moVectorMonitor.h
View file

@ -1,241 +0,0 @@
/*
<moVectorMonitor.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 moVectorMonitor_h
#define moVectorMonitor_h
#include <fstream>
#include <utils/eoMonitor.h>
#include <utils/eoParam.h>
/**
* To save the values of the same type (double, unsigned int, or EOT) in a vector
* It is similar to eoFileMonitor
*
*/
template <class EOT>
class moVectorMonitor : public eoMonitor
{
public:
/**
* Constructor
* @param _param the parameter of type double to save in the vector
*/
moVectorMonitor(eoValueParam<double> & _param) : doubleParam(&_param), intParam(NULL), eotParam(NULL)
{
// precision of the output by default
precisionOutput = std::cout.precision();
}
/**
* Default Constructor
* @param _param the parameter of type unsigned int to save in the vector
*/
moVectorMonitor(eoValueParam<unsigned int> & _param) : doubleParam(NULL), intParam(&_param), eotParam(NULL)
{
// precision of the output by default
precisionOutput = std::cout.precision();
}
/**
* Default Constructor
* @param _param the parameter of type EOT to save in the vector
*/
moVectorMonitor(eoValueParam<EOT> & _param) : doubleParam(NULL), intParam(NULL), eotParam(&_param)
{
// precision of the output by default
precisionOutput = std::cout.precision();
}
/**
* Default Constructor
* @param _param the parameter of type eoScalarFitness to save in the vector
*/
template <class ScalarType, class Compare>
moVectorMonitor(eoValueParam<eoScalarFitness<ScalarType, Compare> > & _param) : doubleParam( & (eoValueParam<double>&)_param), intParam(NULL), eotParam(NULL)
{
// precision of the output by default
precisionOutput = std::cout.precision();
}
/**
* Default Constructor
* @param _param unvalid Parameter
*/
template <class T>
moVectorMonitor(eoValueParam<T> & _param) : doubleParam(NULL), intParam(NULL), eotParam(NULL)
{
std::cerr << "Sorry the type can not be in a vector of moVectorMonitor" << std::endl;
}
/**
* To test if the value are basic type (double or unsigned int), or EOT type
*
* @return true if the type is a EOT type
*/
bool solutionType() {
return eotParam != NULL;
}
/**
* To "print" the value of the parameter in the vector
*
* @return this monitor (sorry I don't why, but it is like this in EO)
*/
eoMonitor& operator()(void) {
if (doubleParam != NULL)
valueVec.push_back(doubleParam->value());
else
if (intParam != NULL)
valueVec.push_back((double) intParam->value());
else
eotVec.push_back(eotParam->value());
return *this ;
}
/**
* To have all the values
*
* @return the vector of values
*/
const std::vector<double>& getValues() const {
return valueVec;
}
/**
* To have all the solutions
*
* @return the vector of solutions
*/
const std::vector<EOT>& getSolutions() const {
return eotVec;
}
/**
* to get the value out.
* @return the string of the value
*/
std::string getValue(unsigned int i) const {
std::ostringstream os;
// set the precision of the output
os.precision(precisionOutput);
if (eotParam == NULL)
os << (valueVec[i]) ;
else
os << (eotVec[i]) ;
return os.str();
}
/**
* clear the vector
*/
void clear() {
valueVec.clear();
eotVec.clear();
}
/**
* number of value
* @return size of the vector
*/
unsigned int size() {
if (eotParam == NULL)
return valueVec.size();
else
return eotVec.size();
}
/**
* to set the precision of the output file
* @param _precision precision of the output (number of digit)
*/
void precision(unsigned int _precision) {
precisionOutput = _precision;
}
/**
* to export the vector of values into one file
* @param _filename file name
* @param _openFile to specify if it writes at the following of the file
*/
void fileExport(std::string _filename, bool _openFile=false) {
// create file
std::ofstream os;
if(! _openFile)
os.open(_filename.c_str());
else
os.open(_filename.c_str(),std::ios::app);
if (!os) {
std::string str = "moVectorMonitor: Could not open " + _filename;
throw std::runtime_error(str);
}
for (unsigned int i = 0; i < size(); i++) {
os << getValue(i);
os << std::endl ;
}
}
/**
* @return name of the class
*/
virtual std::string className(void) const {
return "moVectorMonitor";
}
protected:
eoValueParam<double> * doubleParam ;
eoValueParam<unsigned int> * intParam ;
eoValueParam<EOT> * eotParam ;
std::vector<double> valueVec;
std::vector<EOT> eotVec;
// precision of the output
unsigned int precisionOutput;
};
#endif

104
tags/ParadisEO-GPU-1.1/paradiseo-mo/src/eval/moDoubleIncrEvaluation.h
View file

@ -1,104 +0,0 @@
/*
<moDoubleIncrEvaluation.h>
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 moDoubleIncrEvaluation_H
#define moDoubleIncrEvaluation_H
#include <eval/moNeighborhoodEvaluation.h>
#include <continuator/moUpdater.h>
/**
* Base class for the double incremental evaluation of the neighborhood
*
* The sizes of the neighborhoods are equal
*/
template<class Neighbor>
class moDoubleIncrEvaluation : public moNeighborhoodEvaluation<Neighbor>, public moUpdater
{
public:
typedef typename Neighbor::EOT EOT;
typedef typename EOT::Fitness Fitness;
/**
* Constructor
*
* @param _neighborhoodSize the size of the neighborhood
*/
moDoubleIncrEvaluation(unsigned int _neighborhoodSize) : moNeighborhoodEvaluation<Neighbor>(), moUpdater(), neighborhoodSize(_neighborhoodSize), firstEval(true) {
deltaFitness = new Fitness[neighborhoodSize];
}
/**
* Destructor
*/
~moDoubleIncrEvaluation() {
if (deltaFitness != NULL)
delete [] deltaFitness;
}
/**
* Initialisation of the evaluation process
* The first evaluation will be a simple incremental evaluation
*
*/
virtual void init() {
firstEval = true;
}
virtual void operator()() {
}
/**
* Evaluation of the neighborhood
* Here nothing to do
*
* @param _solution the current solution
*/
virtual void operator()(EOT & _solution) {
}
/** the delta of fitness for each neighbors
* The fitness of the neighbor i is given by : fitness(solution) + deltaFitness[i]
*/
Fitness * deltaFitness;
protected:
/** the neighborhood size */
unsigned int neighborhoodSize;
/** flag : true when it is the first evaluation */
bool firstEval;
};
#endif

76
tags/ParadisEO-GPU-1.1/paradiseo-mo/src/eval/moDoubleIncrNeighborhoodEval.h
View file

@ -1,76 +0,0 @@
/*
<moDoubleIncrNeighborhoodEval.h>
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 moDoubleIncrNeighborhoodEval_H
#define moDoubleIncrNeighborhoodEval_H
#include <eval/moEval.h>
#include <eval/moDoubleIncrEvaluation.h>
/**
* Evaluation of a neighbor from the full evaluation f the neighborhood
*
*
*/
template<class Neighbor>
class moDoubleIncrNeighborhoodEval : public moEval<Neighbor>
{
public:
typedef typename moEval<Neighbor>::EOT EOT;
/**
* Ctor
* @param _evaluation the double incremental evaluation of the neighborhood
*/
moDoubleIncrNeighborhoodEval(moDoubleIncrEvaluation<Neighbor>& _evaluation) : evaluation(_evaluation) {}
/**
* evaluation of a neighbor with the double incremental evaluation
*
* @param _sol current solution
* @param _neighbor the neighbor to be evaluated
*/
void operator()(EOT & _sol, Neighbor & _neighbor)
{
_neighbor.fitness(_sol.fitness() + evaluation.deltaFitness[_neighbor.index()]);
}
private:
/** the evaluation of the neighborhood */
moDoubleIncrEvaluation<Neighbor> & evaluation;
};
#endif

53
tags/ParadisEO-GPU-1.1/paradiseo-mo/src/eval/moDummyEval.h
View file

@ -1,53 +0,0 @@
/*
<moDummyEval.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 ue,
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".
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 _moDummyEval_h
#define _moDummyEval_h
#include <eval/moEval.h>
/**
* Dummy Evaluation function
*/
template<class Neighbor>
class moDummyEval : public moEval<Neighbor> {
public:
typedef typename Neighbor::EOT EOT;
typedef typename EOT::Fitness Fitness;
/**
* NOTHING TO DO
* @param _sol unused solution
* @param _n unused neighbor
*/
void operator()(EOT& _sol, Neighbor& _n) {}
};
#endif

51
tags/ParadisEO-GPU-1.1/paradiseo-mo/src/eval/moEval.h
View file

@ -1,51 +0,0 @@
/*
<moEval.h>
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 moEval_H
#define moEval_H
#include <eoFunctor.h>
/**
* Abstract class for the evaluation
*/
template<class Neighbor>
class moEval : public eoBF<typename Neighbor::EOT &, Neighbor&, void>
{
public:
typedef typename Neighbor::EOT EOT;
typedef typename EOT::Fitness Fitness;
};
#endif

66
tags/ParadisEO-GPU-1.1/paradiseo-mo/src/eval/moEvalCounter.h
View file

@ -1,66 +0,0 @@
/*
<moEvalCounter.h>
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 ue,
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".
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 _moEvalCounter_h
#define _moEvalCounter_h
#include <eval/moEval.h>
#include <utils/eoParam.h>
/**
Counts the number of neighbor evaluations actually performed, thus checks first
if it has to evaluate.. etc.
*/
template<class Neighbor>
class moEvalCounter : public moEval<Neighbor>, public eoValueParam<unsigned long>
{
public:
typedef typename Neighbor::EOT EOT;
typedef typename EOT::Fitness Fitness;
moEvalCounter(moEval<Neighbor>& _eval, std::string _name = "Neighbor Eval. ")
: eoValueParam<unsigned long>(0, _name), eval(_eval) {}
/**
* Increase the number of neighbor evaluations and perform the evaluation
*
* @param _solution a solution
* @param _neighbor a neighbor
*/
void operator()(EOT& _solution, Neighbor& _neighbor) {
value()++;
eval(_solution, _neighbor);
}
private:
moEval<Neighbor> & eval;
};
#endif

82
tags/ParadisEO-GPU-1.1/paradiseo-mo/src/eval/moFullEvalByCopy.h
View file

@ -1,82 +0,0 @@
/*
<moFullEvalByCopy.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 moFullEvalByCopy_H
#define moFullEvalByCopy_H
#include <eoEvalFunc.h>
#include <eval/moEval.h>
/**
* Evaluation by copy
*/
template<class Neighbor>
class moFullEvalByCopy : public moEval<Neighbor>
{
public:
typedef typename moEval<Neighbor>::EOT EOT;
typedef typename moEval<Neighbor>::Fitness Fitness;
/**
* Ctor
* @param _eval the full evaluation object
*/
moFullEvalByCopy(eoEvalFunc<EOT> & _eval) : eval(_eval) {}
/**
* Full evaluation of the neighbor by copy
* @param _sol current solution
* @param _neighbor the neighbor to be evaluated
*/
void operator()(EOT & _sol, Neighbor & _neighbor)
{
// tmp solution
EOT tmp(_sol);
// move tmp solution wrt _neighbor
_neighbor.move(tmp);
// eval copy
tmp.invalidate();
eval(tmp);
// set the fitness value to the neighbor
_neighbor.fitness(tmp.fitness());
}
private:
/** the full evaluation object */
eoEvalFunc<EOT> & eval;
};
#endif

96
tags/ParadisEO-GPU-1.1/paradiseo-mo/src/eval/moFullEvalByModif.h
View file

@ -1,96 +0,0 @@
/*
<moFullEvalByModif.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 moFullEvalByModif_H
#define moFullEvalByModif_H
#include <eoEvalFunc.h>
#include <eval/moEval.h>
/**
* Full evaluation to use with a moBackableNeighbor
* !!!WARNING!!! Use only when your solution is composed by a fitness Value and a "genotype"
*
*/
template<class BackableNeighbor>
class moFullEvalByModif : public moEval<BackableNeighbor>
{
public:
typedef typename moEval<BackableNeighbor>::EOT EOT;
typedef typename moEval<BackableNeighbor>::Fitness Fitness;
/**
* Ctor
* @param _eval the full evaluation object
*/
moFullEvalByModif(eoEvalFunc<EOT>& _eval) : eval(_eval) {}
/**
* Full evaluation of the neighbor by copy
* @param _sol current solution
* @param _neighbor the neighbor to be evaluated
*/
void operator()(EOT & _sol, BackableNeighbor & _neighbor)
{
// tmp fitness value of the current solution
Fitness tmpFit;
// save current fitness value
tmpFit = _sol.fitness();
// move the current solution wrt _neighbor
_neighbor.move(_sol);
// eval the modified solution
_sol.invalidate();
eval(_sol);
// set the fitness value to the neighbor
_neighbor.fitness(_sol.fitness());
// move the current solution back
_neighbor.moveBack(_sol);
// set the fitness back
_sol.fitness(tmpFit);
}
private:
/** the full evaluation object */
eoEvalFunc<EOT> & eval;
};
#endif

56
tags/ParadisEO-GPU-1.1/paradiseo-mo/src/eval/moNeighborhoodEvaluation.h
View file

@ -1,56 +0,0 @@
/*
<moNeighborhoodEvaluation.h>
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 moNeighborhoodEvaluation_H
#define moNeighborhoodEvaluation_H
#include <eoFunctor.h>
/**
* Abstract class for the evaluation
* of all the neighborhood
* in one step
*
* It is usefull for example in a double incremental evaluation (QAP, UBQP problems)
* This class is used in combinaison with the class moEvaluatedNeighborhood
*/
template<class Neighbor>
class moNeighborhoodEvaluation : public eoUF<typename Neighbor::EOT &, void>
{
public:
typedef typename Neighbor::EOT EOT;
typedef typename EOT::Fitness Fitness;
};
#endif

59
tags/ParadisEO-GPU-1.1/paradiseo-mo/src/memory/moAspiration.h
View file

@ -1,59 +0,0 @@
/*
<moAspiration.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 ue,
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".
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 _moAspiration_h
#define _moAspiration_h
#include <eoFunctor.h>
/**
* Abstract class for Aspiration Criteria
*/
template< class Neighbor >
class moAspiration : public eoBF<typename Neighbor::EOT &, Neighbor &, bool>
{
public:
typedef typename Neighbor::EOT EOT;
/**
* Virtual Init
* @param _sol the current solution
*/
virtual void init(EOT & _sol) = 0;
/**
* Virtual update
* @param _sol the current solution
* @param _neighbor the current neighbor
*/
virtual void update(EOT & _sol, Neighbor & _neighbor) = 0;
};
#endif

87
tags/ParadisEO-GPU-1.1/paradiseo-mo/src/memory/moBestImprAspiration.h
View file

@ -1,87 +0,0 @@
/*
<moBestImprAspiration.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 ue,
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".
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 _moBestImprAspiration_h
#define _moBestImprAspiration_h
#include <memory/moAspiration.h>
/**
* Aspiration criteria accepts a solution better than the best so far
*/
template< class Neighbor >
class moBestImprAspiration : public moAspiration<Neighbor>
{
public:
typedef typename Neighbor::EOT EOT;
/**
* init the best solution
* @param _sol the best solution found
*/
void init(EOT & _sol) {
bestFoundSoFar = _sol;
}
/**
* update the "bestFoundSoFar" if a best solution is found
* @param _sol a solution
* @param _neighbor a neighbor
*/
void update(EOT & _sol, Neighbor & _neighbor) {
if (bestFoundSoFar.fitness() < _sol.fitness())
bestFoundSoFar = _sol;
}
/**
* Test the tabu feature of the neighbor:
* test if the neighbor's fitness is better than the "bestFoundSoFar" fitness
* @param _sol a solution
* @param _neighbor a neighbor
* @return true if _neighbor fitness is better than the "bestFoundSoFar"
*/
bool operator()(EOT & _sol, Neighbor & _neighbor) {
return (bestFoundSoFar.fitness() < _neighbor.fitness());
}
/**
* Getter
* @return a reference on the best found so far solution
*/
EOT& getBest() {
return bestFoundSoFar;
}
private:
EOT bestFoundSoFar;
};
#endif

119
tags/ParadisEO-GPU-1.1/paradiseo-mo/src/memory/moCountMoveMemory.h
View file

@ -1,119 +0,0 @@
/*
<moCountMoveMemory.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 ue,
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".
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 _moCountMoveMemory_h
#define _moCountMoveMemory_h
#include <memory/moMemory.h>
/**
* Count the number of move, no move and the successive stagnation since the last Move
*/
template< class Neighbor >
class moCountMoveMemory : virtual public moMemory<Neighbor> {
public:
typedef typename Neighbor::EOT EOT;
/**
* Init all the counters
* @param _sol unused solution
*/
void init(EOT & _sol) {
nbMove=0;
nbNoMove=0;
counter=0;
}
/**
* @param _sol unused solution
* @param _neighbor unused neighbor
*/
void add(EOT & _sol, Neighbor & _neighbor) {
nbMove++;
counter=0;
}
/**
* @param _sol unused solution
* @param _neighbor unused neighbor
*/
void update(EOT & _sol, Neighbor & _neighbor) {
nbNoMove++;
counter++;
}
/**
* ClearMemory : Reinit all the counters
*/
void clearMemory() {
nbMove=0;
nbNoMove=0;
counter=0;
}
/**
* Getter of the number of move
* @return the counter
*/
unsigned int getNbMove() {
return nbMove;
}
/**
* Getter of the number of no move
* @return the counter
*/
unsigned int getNbNoMove() {
return nbNoMove;
}
/**
* Getter of the number of successive stagnation since the last Move
* @return the counter
*/
unsigned int getCounter() {
return counter;
}
/**
* Init counter
*/
void initCounter() {
counter=0;
}
private:
unsigned int nbMove;
unsigned int nbNoMove;
unsigned int counter;
};
#endif

42
tags/ParadisEO-GPU-1.1/paradiseo-mo/src/memory/moDiversification.h
View file

@ -1,42 +0,0 @@
/*
<moDiversification.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 ue,
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".
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 _moDiversification_h
#define _moDiversification_h
#include <memory/moMemory.h>
#include <eoFunctor.h>
/**
* Abstract class for diversification strategy
*/
template< class Neighbor >
class moDiversification : virtual public moMemory<Neighbor>, public eoUF<typename Neighbor::EOT &,bool> {};
#endif

53
tags/ParadisEO-GPU-1.1/paradiseo-mo/src/memory/moDummyDiversification.h
View file

@ -1,53 +0,0 @@
/*
<moDummyDiversification.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 ue,
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".
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 _moDummyDiversification_h
#define _moDummyDiversification_h
#include <memory/moDiversification.h>
#include <memory/moDummyMemory.h>
/**
* Dummy diversification strategy
*/
template< class Neighbor >
class moDummyDiversification : public moDiversification<Neighbor>, public moDummyMemory<Neighbor>
{
public:
typedef typename Neighbor::EOT EOT;
/**
* @return always false
*/
bool operator()(EOT &) {
return false;
}
};
#endif

53
tags/ParadisEO-GPU-1.1/paradiseo-mo/src/memory/moDummyIntensification.h
View file

@ -1,53 +0,0 @@
/*
<moDummyIntensification.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 ue,
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".
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 _moDummyIntensification_h
#define _moDummyIntensification_h
#include <memory/moIntensification.h>
#include <memory/moDummyMemory.h>
/**
* Dummy intensification strategy
*/
template< class Neighbor >
class moDummyIntensification : public moIntensification<Neighbor>, public moDummyMemory<Neighbor>
{
public:
typedef typename Neighbor::EOT EOT;
/**
* @return always false
*/
bool operator()(EOT &) {
return false;
}
};
#endif

67
tags/ParadisEO-GPU-1.1/paradiseo-mo/src/memory/moDummyMemory.h
View file

@ -1,67 +0,0 @@
/*
<moDummyMemory.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 ue,
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".
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 _moDummyMemory_h
#define _moDummyMemory_h
#include <memory/moMemory.h>
/**
* Dummy memory to make an empty memory
*/
template< class Neighbor >
class moDummyMemory : virtual public moMemory<Neighbor> {
public:
typedef typename Neighbor::EOT EOT;
/**
* Init : NOTHIING TO DO
*/
void init(EOT & _sol) {}
/**
* Add : NOTHIING TO DO
*/
void add(EOT & _sol, Neighbor & _neighbor) {}
/**
* Update : NOTHIING TO DO
*/
void update(EOT & _sol, Neighbor & _neighbor) {}
/**
* ClearMemory : NOTHIING TO DO
*/
void clearMemory() {}
};
#endif

121
tags/ParadisEO-GPU-1.1/paradiseo-mo/src/memory/moIndexedVectorTabuList.h
View file

@ -1,121 +0,0 @@
/*
<moIndexedVectorTabuList.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 ue,
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".
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 _moIndexedVectorTabuList_h
#define _moIndexedVectorTabuList_h
#include <memory/moTabuList.h>
#include <vector>
#include <iostream>
/**
* Tabu List of indexed neighbors save in a vector
* each neighbor can not used during howlong iterations
*/
template<class Neighbor >
class moIndexedVectorTabuList : public moTabuList<Neighbor>
{
public:
typedef typename Neighbor::EOT EOT;
/**
* Constructor
* @param _maxSize maximum size of the tabu list
* @param _howlong how many iteration a move is tabu
*/
moIndexedVectorTabuList(unsigned int _maxSize, unsigned int _howlong) : maxSize(_maxSize), howlong(_howlong) {
tabuList.resize(_maxSize);
}
/**
* init the tabuList by clearing the memory
* @param _sol the current solution
*/
virtual void init(EOT & _sol) {
clearMemory();
}
/**
* add a new neighbor in the tabuList
* @param _sol unused solution
* @param _neighbor the current neighbor
*/
virtual void add(EOT & _sol, Neighbor & _neighbor) {
if (_neighbor.index() < maxSize)
tabuList[_neighbor.index()] = howlong;
}
/**
* update the tabulist by decreasing the number of tabu iteration
* @param _sol unused solution
* @param _neighbor unused neighbor
*/
virtual void update(EOT & _sol, Neighbor & _neighbor) {
for (unsigned int i = 0; i < maxSize; i++)
if (tabuList[i] > 0)
tabuList[i]--;
}
/**
* check if the move is tabu
* @param _sol unused solution
* @param _neighbor the current neighbor
* @return true if tabuList contains _sol
*/
virtual bool check(EOT & _sol, Neighbor & _neighbor) {
return (tabuList[_neighbor.index()] > 0);
}
/**
* clearMemory: remove all solution of the tabuList
*/
virtual void clearMemory() {
for (unsigned int i = 0; i < maxSize; i++)
tabuList[i] = 0;
}
void print(){
std::cout << "Tabulist:" << std::endl;
for(int i=0; i<tabuList.size(); i++)
std::cout << i << ": " << tabuList[i] << std::endl;
}
protected:
//tabu list
std::vector< unsigned int > tabuList;
//maximum size of the tabu list
unsigned int maxSize;
//how many iteration a move is tabu
unsigned int howlong;
};
#endif

42
tags/ParadisEO-GPU-1.1/paradiseo-mo/src/memory/moIntensification.h
View file

@ -1,42 +0,0 @@
/*
<moIntensification.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 ue,
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".
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 _moIntensification_h
#define _moIntensification_h
#include <memory/moMemory.h>
#include <eoFunctor.h>
/**
* Abstract class for intensification strategy
*/
template< class Neighbor >
class moIntensification : virtual public moMemory<Neighbor>, public eoUF<typename Neighbor::EOT &,bool> {};
#endif

40
tags/ParadisEO-GPU-1.1/paradiseo-mo/src/memory/moMemory.h
View file

@ -1,40 +0,0 @@
#ifndef _moMemory_h
#define _moMemory_h
/**
* Abstract class for different memory
*/
template< class Neighbor >
class moMemory //: public eoObject
{
public:
typedef typename Neighbor::EOT EOT;
/**
* Init the memory
* @param _sol the current solution
*/
virtual void init(EOT & _sol) = 0;
/**
* Add data to the memory
* @param _sol the current solution
* @param _neighbor the current neighbor
*/
virtual void add(EOT & _sol, Neighbor & _neighbor) = 0;
/**
* update the memory
* @param _sol the current solution
* @param _neighbor the current neighbor
*/
virtual void update(EOT & _sol, Neighbor & _neighbor) = 0;
/**
* clear the memory
*/
virtual void clearMemory() = 0;
};
#endif

72
tags/ParadisEO-GPU-1.1/paradiseo-mo/src/memory/moMonOpDiversification.h
View file

@ -1,72 +0,0 @@
/*
<moMonOpDiversification.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 ue,
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".
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 _moMonOpDiversification_h
#define _moMonOpDiversification_h
#include <eoEvalFunc.h>
#include <eoOp.h>
#include <memory/moDiversification.h>
#include <memory/moDummyMemory.h>
/**
* Diversification strategy applies a "monOp" operator
*/
template< class Neighbor >
class moMonOpDiversification : public moDiversification<Neighbor>, public moDummyMemory<Neighbor>
{
public:
typedef typename Neighbor::EOT EOT;
/**
* Constructor
* @param _monOp an eoMonOp (diversification operator)
* @param _fullEval a full evaluation function
*/
moMonOpDiversification(eoMonOp<EOT>& _monOp, eoEvalFunc<EOT>& _fullEval):monOp(_monOp), fullEval(_fullEval) {}
/**
* Apply monOp on the solution
* @param _solution to diversify
* @return value of monOp
*/
bool operator()(EOT& _solution) {
bool res = monOp(_solution);
fullEval(_solution);
return res;
}
private:
/** monOp */
eoMonOp<EOT>& monOp;
eoEvalFunc<EOT>& fullEval;
};
#endif

138
tags/ParadisEO-GPU-1.1/paradiseo-mo/src/memory/moNeighborVectorTabuList.h
View file

@ -1,138 +0,0 @@
/*
<moNeighborVectorTabuList.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 ue,
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".
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 _moNeighborVectorTabuList_h
#define _moNeighborVectorTabuList_h
#include <memory/moTabuList.h>
#include <vector>
#include <iostream>
/**
* Tabu List of neighbors stocked in a vector
*/
template<class Neighbor >
class moNeighborVectorTabuList : public moTabuList<Neighbor>
{
public:
typedef typename Neighbor::EOT EOT;
/**
* Constructor
* @param _maxSize maximum size of the tabu list
* @param _howlong how many iteration a move is tabu (0 -> no limits)
*/
moNeighborVectorTabuList(unsigned int _maxSize, unsigned int _howlong) : maxSize(_maxSize), howlong(_howlong), index(0) {
tabuList.reserve(_maxSize);
tabuList.resize(0);
}
/**
* init the tabuList by clearing the memory
* @param _sol the current solution
*/
virtual void init(EOT & _sol) {
clearMemory();
}
/**
* add a new neighbor in the tabuList
* @param _sol unused solution
* @param _neighbor the current neighbor
*/
virtual void add(EOT & _sol, Neighbor & _neighbor) {
if (tabuList.size() < maxSize) {
std::pair<Neighbor, unsigned int> tmp;
tmp.first=_neighbor;
tmp.second=howlong;
tabuList.push_back(tmp);
}
else {
tabuList[index%maxSize].first = _neighbor;
tabuList[index%maxSize].second = howlong;
index++;
}
}
/**
* update the tabulist
* @param _sol unused solution
* @param _neighbor unused neighbor
*/
virtual void update(EOT & _sol, Neighbor & _neighbor) {
if (howlong > 0)
for (unsigned int i=0; i<tabuList.size(); i++)
if (tabuList[i].second > 0)
tabuList[i].second--;
}
/**
* check if the move is tabu
* @param _sol unused solution
* @param _neighbor the current neighbor
* @return true if tabuList contains _sol
*/
virtual bool check(EOT & _sol, Neighbor & _neighbor) {
for (unsigned int i=0; i<tabuList.size(); i++) {
if ((howlong > 0 && tabuList[i].second > 0 && tabuList[i].first.equals(_neighbor)) || (howlong==0 && tabuList[i].first.equals(_neighbor)))
return true;
}
return false;
}
/**
* clearMemory: remove all solution of the tabuList
*/
virtual void clearMemory() {
tabuList.resize(0);
index = 0;
}
void print(){
std::cout << "TAbulist:" << std::endl;
for(int i=0; i<tabuList.size(); i++)
std::cout << i << ": " << tabuList[i].first.index() << std::endl;
}
private:
//tabu list
std::vector< std::pair<Neighbor, unsigned int> > tabuList;
//maximum size of the tabu list
unsigned int maxSize;
//how many iteration a move is tabu
unsigned int howlong;
//index on the tabulist
unsigned long index;
};
#endif

81
tags/ParadisEO-GPU-1.1/paradiseo-mo/src/memory/moRndIndexedVectorTabuList.h
View file

@ -1,81 +0,0 @@
/*
<moRndIndexedVectorTabuList.h>
Copyright (C) DOLPHIN Project-Team, INRIA Lille - Nord Europe, 2006-2010
Sebastien Verel
This software is governed by the CeCILL license under French law and
abiding by the rules of distribution of free software. You can ue,
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".
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 _moRndIndexedVectorTabuList_h
#define _moRndIndexedVectorTabuList_h
#include <memory/moIndexedVectorTabuList.h>
#include <utils/eoRndGenerators.h>
/**
* Tabu List of indexed neighbors save in a vector
* each neighbor can not used during howlong + rnd(howlongRnd) iterations
* see paper:
* Zhipeng Lu, Fred Glover, Jin-Kao Hao. "A Hybrid Metaheuristic Approach to Solving the UBQP Problem". European Journal of Operational Research, 2010.
*/
template<class Neighbor >
class moRndIndexedVectorTabuList : public moIndexedVectorTabuList<Neighbor>
{
public:
typedef typename Neighbor::EOT EOT;
//tabu list
using moIndexedVectorTabuList<Neighbor>::tabuList;
//maximum size of the tabu list
using moIndexedVectorTabuList<Neighbor>::maxSize;
//how many iteration a move is tabu
using moIndexedVectorTabuList<Neighbor>::howlong;
/**
* Constructor
* @param _maxSize maximum size of the tabu list
* @param _howlong how many minimal iteration a move is tabu
* @param _howlongRnd how many additional iterations a move is tabu (random between [0 , _howlongRnd [ )
*/
moRndIndexedVectorTabuList(unsigned int _maxSize, unsigned int _howlong, unsigned int _howlongRnd) : moIndexedVectorTabuList<Neighbor>(_maxSize, _howlong), howlongRnd(_howlongRnd) {
}
/**
* add a new neighbor in the tabuList
* @param _sol unused solution
* @param _neighbor the current neighbor
*/
virtual void add(EOT & _sol, Neighbor & _neighbor) {
if (_neighbor.index() < maxSize)
tabuList[_neighbor.index()] = howlong + rng.uniform(howlongRnd) ;
}
protected:
// the random part of the forbidden time
unsigned int howlongRnd;
};
#endif

134
tags/ParadisEO-GPU-1.1/paradiseo-mo/src/memory/moSolVectorTabuList.h
View file

@ -1,134 +0,0 @@
/*
<moSolVectorTabuList.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 ue,
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".
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 _moSolVectorTabuList_h
#define _moSolVectorTabuList_h
#include <memory/moTabuList.h>
#include <vector>
#include <iostream>
/**
* Tabu List of solution stocked in a vector
*/
template<class Neighbor >
class moSolVectorTabuList : public moTabuList<Neighbor>
{
public:
typedef typename Neighbor::EOT EOT;
/**
* Constructor
* @param _maxSize maximum size of the tabu list
* @param _howlong how many iteration a solution is tabu
*/
moSolVectorTabuList(unsigned int _maxSize, unsigned int _howlong) : maxSize(_maxSize), howlong(_howlong) {
tabuList.reserve(_maxSize);
tabuList.resize(0);
}
/**
* init the tabuList by clearing the memory
* @param _sol the current solution
*/
virtual void init(EOT & _sol) {
clearMemory();
}
/**
* add a new solution in the tabuList
* @param _sol the current solution
* @param _neighbor unused neighbor
*/
virtual void add(EOT & _sol, Neighbor & _neighbor) {
if (tabuList.size() < maxSize) {
std::pair<EOT, unsigned int> tmp;
tmp.first=_sol;
tmp.second=howlong;
tabuList.push_back(tmp);
}
else {
tabuList[index%maxSize].first = _sol;
tabuList[index%maxSize].second = howlong;
index++;
}
}
/**
* update the tabulist: NOTHING TO DO
* @param _sol the current solution
* @param _neighbor the current neighbor (unused)
*/
virtual void update(EOT & _sol, Neighbor & _neighbor) {
if (howlong > 0)
for (unsigned int i=0; i<tabuList.size(); i++)
if (tabuList[i].second > 0)
tabuList[i].second--;
}
/**
* check if the solution is tabu
* @param _sol the current solution
* @param _neighbor the current neighbor (unused)
* @return true if tabuList contains _sol
*/
virtual bool check(EOT & _sol, Neighbor & _neighbor) {
EOT tmp=_sol;
_neighbor.move(tmp);
for (unsigned int i=0; i<tabuList.size(); i++) {
if ((howlong > 0 && tabuList[i].second > 0 && tabuList[i].first == tmp) || (howlong==0 && tabuList[i].first==tmp))
return true;
}
return false;
}
/**
* clearMemory: remove all solution of the tabuList
*/
virtual void clearMemory() {
tabuList.resize(0);
index = 0;
}
private:
//tabu list
std::vector< std::pair<EOT, unsigned int> > tabuList;
//maximum size of the tabu list
unsigned int maxSize;
//how many iteration a move is tabu
unsigned int howlong;
//index on the tabulist
unsigned long index;
};
#endif

53
tags/ParadisEO-GPU-1.1/paradiseo-mo/src/memory/moTabuList.h
View file

@ -1,53 +0,0 @@
/*
<moTabuList.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 ue,
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".
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 _moTabuList_h
#define _moTabuList_h
#include <memory/moMemory.h>
/**
* Abstract class for the Tabu List
*/
template< class Neighbor >
class moTabuList : public moMemory<Neighbor>
{
public:
typedef typename Neighbor::EOT EOT;
/**
* Check if a neighbor is tabu or not
* @param _sol the current solution
* @param _neighbor the neighbor
* @return true if the neighbor is tabu
*/
virtual bool check(EOT & _sol, Neighbor & _neighbor) = 0;
};
#endif

56
tags/ParadisEO-GPU-1.1/paradiseo-mo/src/neighborhood/moBackableNeighbor.h
View file

@ -1,56 +0,0 @@
/*
<moBackableNeighbor.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 _BackableNeighbor_h
#define _BackableNeighbor_h
#include <neighborhood/moNeighbor.h>
/**
* Neighbor with a move back function to use in a moFullEvalByModif
*/
template< class EOT, class Fitness=typename EOT::Fitness >
class moBackableNeighbor : virtual public moNeighbor<EOT, Fitness>
{
public:
/**
* the function to move back a solution
* @param _solution the solution to moveBack
*/
virtual void moveBack(EOT & _solution)=0;
};
#endif

100
tags/ParadisEO-GPU-1.1/paradiseo-mo/src/neighborhood/moBackwardVectorVNSelection.h
View file

@ -1,100 +0,0 @@
/*
<moBackwardVectorVNSelection.h>
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 ue,
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".
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 _moBackwardVectorVNSelection_h
#define _moBackwardVectorVNSelection_h
#include <neighborhood/moVectorVNSelection.h>
/**
* This class is used for the Variable Neighborhood Search explorer inherits from moVectorVNSelection
* The search heuristics are saved in vectors
* They are given in backward order from the last ones to the first ones
*
*/
template< class EOT >
class moBackwardVectorVNSelection: public moVectorVNSelection<EOT>{
using moVectorVNSelection<EOT>::LSvector;
using moVectorVNSelection<EOT>::current;
public:
/**
* Default constructor with first search heuristics
*
* @param _firstLS first local search
* @param _firstShake first heuristic which perturbs the solution
* @param _cycle when true, the first heuristics follows the last ones. Otherwise the search stop.
*/
moBackwardVectorVNSelection(eoMonOp<EOT>& _firstLS, eoMonOp<EOT>& _firstShake, bool _cycle = true) : moVectorVNSelection<EOT>(_firstLS, _firstShake), cycle(_cycle){}
/**
* Return the class id.
* @return the class name as a std::string
*/
virtual std::string className() const {
return "moBackwardVectorVNSelection";
}
/**
* test if there is still some heuristics
*
* @param _solution the current solution
* @return true if there is some heuristics
*/
virtual bool cont(EOT& _solution){
return (cycle || (current > 0));
}
/**
* put the current heuristics on the first ones
*
* @param _solution the current solution
*/
virtual void init(EOT& _solution){
current = LSvector.size() - 1;
}
/**
* put the current heuristics on the next ones
*
* @param _solution the current solution
*/
virtual void next(EOT& _solution){
current = (current + LSvector.size() -1) % LSvector.size();
}
private:
// boolean to indicate the last heuristics follow the first ones
bool cycle;
};
#endif

48
tags/ParadisEO-GPU-1.1/paradiseo-mo/src/neighborhood/moDummyNeighbor.h
View file

@ -1,48 +0,0 @@
/*
<moDummyNeighbor.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 ue,
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".
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 _moDummyNeighbor_h
#define _moDummyNeighbor_h
#include <neighborhood/moNeighbor.h>
/**
* Dummy Neighborhood
*/
template< class EOT, class Fitness=typename EOT::Fitness >
class moDummyNeighbor : public moNeighbor< EOT, Fitness > {
public:
/**
* NOTHING TO DO
* @param _solution the related solution
*/
virtual void move(EOT& _solution) {}
};
#endif

78
tags/ParadisEO-GPU-1.1/paradiseo-mo/src/neighborhood/moDummyNeighborhood.h
View file

@ -1,78 +0,0 @@
/*
<moDummyNeighborhood.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 ue,
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".
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 _moDummyNeighborhood_h
#define _moDummyNeighborhood_h
#include <neighborhood/moDummyNeighbor.h>
#include <neighborhood/moNeighborhood.h>
/**
* Dummy Neighborhood
*/
template< class Neighbor >
class moDummyNeighborhood : public moNeighborhood<Neighbor> {
public:
typedef typename Neighbor::EOT EOT;
/**
* NOTHING TO DO
* @param _solution unused solution
* @return always false
*/
virtual bool hasNeighbor(EOT & _solution) {
return false;
}
/**
* NOTHING TO DO
* @param _solution unused solution
* @param _current unused neighbor
*/
virtual void init(EOT & _solution, Neighbor & _current) {}
/**
* NOTHING TO DO
* @param _solution unused solution
* @param _current unused neighbor
*/
virtual void next(EOT & _solution, Neighbor & _current) {}
/**
* NOTHING TO DO
* @param _solution unused solution
* @return always false
*/
virtual bool cont(EOT & _solution) {
return false;
}
};
#endif

128
tags/ParadisEO-GPU-1.1/paradiseo-mo/src/neighborhood/moEvaluatedNeighborhood.h
View file

@ -1,128 +0,0 @@
/*
<moEvaluatedNeighborhood.h>
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 _moEvaluatedNeighborhood_h
#define _moEvaluatedNeighborhood_h
#include <neighborhood/moNeighborhood.h>
#include <eval/moNeighborhoodEvaluation.h>
/**
* A Neighborhood for the evaluation of all neighbors
* in one step
*
* It is usefull for example in a double incremental evaluation (QAP, UBQP problems)
* This class is used in combinaison with the class moNeighborhoodEvaluation
*/
template<class Neighbor>
class moEvaluatedNeighborhood: public moNeighborhood<Neighbor> {
public:
/**
* Define type of a solution corresponding to Neighbor
*/
typedef typename Neighbor::EOT EOT;
/**
* Constructor
* @param _originalNeighborhood the original neighborhood to apply
* @param _nhEval the evaluation function of the neighborhood
*/
moEvaluatedNeighborhood(moNeighborhood<Neighbor> & _originalNeighborhood, moNeighborhoodEvaluation<Neighbor> & _nhEval) :
moNeighborhood<Neighbor>(), originalNeighborhood(_originalNeighborhood), nhEval(_nhEval) {
}
/**
* @return true if the neighborhood is random (default false)
*/
virtual bool isRandom() {
return originalNeighborhood.isRandom();
}
/**
* Test if a neighbor exists
* @param _solution the solution to explore
* @return true if the neighborhood was not empty
*/
virtual bool hasNeighbor(EOT& _solution) {
return originalNeighborhood.hasNeighbor(_solution);
}
/**
* Initialization of the neighborhood with the full evaluation
*
* @param _solution the solution to explore
* @param _neighbor the first neighbor
*/
virtual void init(EOT & _solution, Neighbor & _neighbor) {
// full evaluation of the neighborhood
nhEval(_solution);
// initialisation of the original neighborhood
originalNeighborhood.init(_solution, _neighbor);
}
/**
* Give the next neighbor with the original neighborhood
* @param _solution the solution to explore
* @param _neighbor the next neighbor
*/
virtual void next(EOT & _solution, Neighbor & _neighbor) {
originalNeighborhood.next(_solution, _neighbor);
}
/**
* give the continuation with the original neighborhood
*
* @param _solution the solution to explore
* @return true if there is again a neighbor to explore
*/
virtual bool cont(EOT & _solution) {
return originalNeighborhood.cont(_solution);
}
/**
* Return the class Name
* @return the class name as a std::string
*/
virtual std::string className() const {
return "moEvaluatedNeighborhood";
}
protected:
moNeighborhood<Neighbor> & originalNeighborhood;
moNeighborhoodEvaluation<Neighbor> & nhEval ;
};
#endif

100
tags/ParadisEO-GPU-1.1/paradiseo-mo/src/neighborhood/moForwardVectorVNSelection.h
View file

@ -1,100 +0,0 @@
/*
<moForwardVectorVNSelection.h>
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 ue,
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".
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 _moForwardVectorVNSelection_h
#define _moForwardVectorVNSelection_h
#include <neighborhood/moVectorVNSelection.h>
/**
* This class is used for the Variable Neighborhood Search explorer inherits from moVectorVNSelection
* The search heuristics are saved in vectors
* They are given in forward order from the first ones to the last ones
*
*/
template< class EOT >
class moForwardVectorVNSelection: public moVectorVNSelection<EOT>{
using moVectorVNSelection<EOT>::LSvector;
using moVectorVNSelection<EOT>::current;
public:
/**
* Default constructor with first search heuristics
*
* @param _firstLS first local search
* @param _firstShake first heuristic which perturbs the solution
* @param _cycle when true, the first heuristics follows the last ones. Otherwise the search stop.
*/
moForwardVectorVNSelection(eoMonOp<EOT>& _firstLS, eoMonOp<EOT>& _firstShake, bool _cycle = true) : moVectorVNSelection<EOT>(_firstLS, _firstShake), cycle(_cycle){}
/**
* Return the class id.
* @return the class name as a std::string
*/
virtual std::string className() const {
return "moForwardVectorVNSelection";
}
/**
* test if there is still some heuristics
*
* @param _solution the current solution
* @return true if there is some heuristics
*/
virtual bool cont(EOT& _solution){
return (cycle || (current <= (LSvector.size() - 2)));
}
/**
* put the current heuristics on the first ones
*
* @param _solution the current solution
*/
virtual void init(EOT& _solution){
current = 0;
}
/**
* put the current heuristics on the next ones
*
* @param _solution the current solution
*/
virtual void next(EOT& _solution){
current = (current + 1) % LSvector.size();
}
private:
// boolean to indicate the first heuristics follow the last ones
bool cycle;
};
#endif

115
tags/ParadisEO-GPU-1.1/paradiseo-mo/src/neighborhood/moIndexNeighbor.h
View file

@ -1,115 +0,0 @@
/*
<moIndexNeighbor.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 _IndexNeighbor_h
#define _IndexNeighbor_h
#include <neighborhood/moNeighbor.h>
/**
* Index Neighbor
*/
template<class EOT, class Fitness = typename EOT::Fitness>
class moIndexNeighbor: virtual public moNeighbor<EOT, Fitness> {
public:
using moNeighbor<EOT, Fitness>::fitness;
/**
* Default Constructor
*/
moIndexNeighbor() :
moNeighbor<EOT, Fitness> (), key(0) {
}
/**
* Copy Constructor
* @param _n the neighbor to copy
*/
moIndexNeighbor(const moIndexNeighbor& _n) :
moNeighbor<EOT, Fitness> (_n) {
this->key = _n.key;
}
/**
* Assignment operator
* @param _source the source neighbor
*/
moIndexNeighbor<EOT, Fitness> & operator=(const moIndexNeighbor<EOT,
Fitness> & _source) {
moNeighbor<EOT, Fitness>::operator=(_source);
this->key = _source.key;
return *this;
}
/**
* Return the class Name
* @return the class name as a std::string
*/
virtual std::string className() const {
return "moIndexNeighbor";
}
/**
* Getter
* @return index of the IndexNeighbor
*/
unsigned int index() {
return key;
}
/**
* Setter
* @param _key index of the IndexNeighbor
*/
void index(unsigned int _key) {
key = _key;
}
/**
* @param _neighbor a neighbor
* @return if _neighbor and this one are equals
*/
virtual bool equals(moIndexNeighbor<EOT>& _neighbor) {
return (key == _neighbor.index());
}
protected:
// key allowing to describe the neighbor
unsigned int key;
};
#endif

89
tags/ParadisEO-GPU-1.1/paradiseo-mo/src/neighborhood/moIndexNeighborhood.h
View file

@ -1,89 +0,0 @@
/*
<moIndexNeighborhood.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 _moIndexNeighborhood_h
#define _moIndexNeighborhood_h
#include <neighborhood/moNeighborhood.h>
/**
* A Indexed Neighborhood
*/
template<class Neighbor>
class moIndexNeighborhood: virtual public moNeighborhood<Neighbor> {
public:
/**
* Define type of a solution corresponding to Neighbor
*/
typedef typename Neighbor::EOT EOT;
/**
* Constructor
* @param _neighborhoodSize the size of the neighborhood
*/
moIndexNeighborhood(unsigned int _neighborhoodSize) :
neighborhoodSize(_neighborhoodSize) {
}
/**
* getter to get the value of neighborhoodSize
* @return the neighborhoodSize
*/
unsigned int getNeighborhoodSize() const {
return neighborhoodSize;
}
/**
* Setter to fixe the neighoodSize
* @param _neighborhoodSize the value to set
*/
void setNeighborhoodSize(unsigned int _neighborhoodSize) {
neighborhoodSize = _neighborhoodSize;
}
/**
* Return the class Name
* @return the class name as a std::string
*/
virtual std::string className() const {
return "moIndexNeighborhood";
}
protected:
// size of the neighborhood
unsigned int neighborhoodSize;
};
#endif

110
tags/ParadisEO-GPU-1.1/paradiseo-mo/src/neighborhood/moNeighbor.h
View file

@ -1,110 +0,0 @@
/*
<moNeighbor.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 _moNeighbor_h
#define _moNeighbor_h
//EO inclusion
#include <EO.h>
#include <eoObject.h>
#include <eoPersistent.h>
/**
* Container of the neighbor informations
*/
template<class EOType, class Fitness = typename EOType::Fitness>
class moNeighbor: public EO<Fitness> {
public:
typedef EOType EOT;
using EO<Fitness>::fitness;
/**
* Default Constructor
*/
moNeighbor() :
EO<Fitness> () {
}
/**
* Copy Constructor
* @param _neighbor to copy
*/
moNeighbor(const moNeighbor<EOT, Fitness>& _neighbor) {
if (!(_neighbor.invalid()))
fitness(_neighbor.fitness());
else
(*this).invalidate();
}
/**
* Assignment operator
* @param _neighbor the neighbor to assign
* @return a neighbor equal to the other
*/
virtual moNeighbor<EOT, Fitness>& operator=(
const moNeighbor<EOT, Fitness>& _neighbor) {
if (!(_neighbor.invalid()))
fitness(_neighbor.fitness());
else
(*this).invalidate();
return (*this);
}
/**
* Move a solution
* @param _solution the related solution
*/
virtual void move(EOT & _solution) = 0;
/**
* Test equality between two neighbors
* @param _neighbor a neighbor
* @return if _neighbor and this one are equals
*/
virtual bool equals(moNeighbor<EOT, Fitness> & _neighbor) {
return false;
}
/**
* Return the class Name
* @return the class name as a std::string
*/
virtual std::string className() const {
return "moNeighbor";
}
};
#endif

101
tags/ParadisEO-GPU-1.1/paradiseo-mo/src/neighborhood/moNeighborhood.h
View file

@ -1,101 +0,0 @@
/*
<moNeighborhood.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 _moNeighborhood_h
#define _moNeighborhood_h
#include <eoObject.h>
/**
* A Neighborhood
*/
template< class Neighbor >
class moNeighborhood : public eoObject
{
public:
/**
* Define type of a solution corresponding to Neighbor
*/
typedef typename Neighbor::EOT EOT;
/**
* Default Constructor
*/
moNeighborhood() {}
/**
* @return true if the neighborhood is random (default false)
*/
virtual bool isRandom() {
return false;
}
/**
* Test if a solution has (again) a Neighbor
* @param _solution the related solution
* @return true if _solution has a Neighbor
*/
virtual bool hasNeighbor(EOT & _solution) = 0 ;
/**
* Initialization of the neighborhood
* @param _solution the solution to explore
* @param _current the first neighbor
*/
virtual void init(EOT & _solution, Neighbor & _current) = 0 ;
/**
* Give the next neighbor
* @param _solution the solution to explore
* @param _current the next neighbor
*/
virtual void next(EOT & _solution, Neighbor & _current) = 0 ;
/**
* Test if there is again a neighbor
* @param _solution the solution to explore
* @return true if there is again a neighbor not explored
*/
virtual bool cont(EOT & _solution) = 0 ;
/**
* Return the class Name
* @return the class name as a std::string
*/
virtual std::string className() const {
return "moNeighborhood";
}
};
#endif

130
tags/ParadisEO-GPU-1.1/paradiseo-mo/src/neighborhood/moOrderNeighborhood.h
View file

@ -1,130 +0,0 @@
/*
<moOrderNeighborhood.h>
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 _moOrderNeighborhood_h
#define _moOrderNeighborhood_h
#include <neighborhood/moIndexNeighborhood.h>
/**
* An ordered Neighborhood
*/
template<class Neighbor>
class moOrderNeighborhood: public moIndexNeighborhood<Neighbor> {
public:
/**
* Define type of a solution corresponding to Neighbor
*/
typedef typename Neighbor::EOT EOT;
using moIndexNeighborhood<Neighbor>::neighborhoodSize;
/**
* Constructor
* @param _neighborhoodSize the size of the neighborhood
*/
moOrderNeighborhood(unsigned int _neighborhoodSize) :
moIndexNeighborhood<Neighbor> (_neighborhoodSize), currentIndex(0) {
}
/**
* Test if a neighbor exists
* @param _solution the solution to explore
* @return true if the neighborhood was not empty
*/
virtual bool hasNeighbor(EOT& _solution) {
return neighborhoodSize > 0;
}
/**
* Initialization of the neighborhood
* @param _solution the solution to explore
* @param _neighbor the first neighbor
*/
virtual void init(EOT & _solution, Neighbor & _neighbor) {
currentIndex = 0;
_neighbor.index(currentIndex);
}
/**
* Give the next neighbor
* @param _solution the solution to explore
* @param _neighbor the next neighbor
*/
virtual void next(EOT & _solution, Neighbor & _neighbor) {
currentIndex++;
_neighbor.index(currentIndex);
}
/**
* test if all neighbors are explore or not,if false, there is no neighbor left to explore
* currentIndex is the index which have been used before, it is not the next neighbor which can be possibly evaluated
*
* @param _solution the solution to explore
* @return true if there is again a neighbor to explore
*/
virtual bool cont(EOT & _solution) {
return (currentIndex < neighborhoodSize - 1);
}
/**
* Getter
* @return the position in the Neighborhood
*/
unsigned int position() {
return currentIndex;
}
/**
* Setter the position in the Neighborhood
*/
void setPosition(unsigned int _currentIndex) {
currentIndex=_currentIndex;
}
/**
* Return the class Name
* @return the class name as a std::string
*/
virtual std::string className() const {
return "moOrderNeighborhood";
}
protected:
unsigned int currentIndex;
};
#endif

51
tags/ParadisEO-GPU-1.1/paradiseo-mo/src/neighborhood/moRndNeighborhood.h
View file

@ -1,51 +0,0 @@
/*
<moRndNeighborhood.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 ue,
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".
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 _moRndNeighborhood_h
#define _moRndNeighborhood_h
#include <neighborhood/moNeighborhood.h>
/**
* Class used to specify a neighborhood is random
*/
template< class Neighbor >
class moRndNeighborhood : virtual public moNeighborhood<Neighbor> {
public:
/**
* @return true
*/
bool isRandom() {
return true;
}
};
#endif

118
tags/ParadisEO-GPU-1.1/paradiseo-mo/src/neighborhood/moRndVectorVNSelection.h
View file

@ -1,118 +0,0 @@
/*
<moRndVectorVNSelection.h>
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 ue,
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".
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 _moRndVectorVNSelection_h
#define _moRndVectorVNSelection_h
#include <utils/eoRndGenerators.h>
#include <utils/rnd_generators.h>
#include <neighborhood/moVectorVNSelection.h>
/**
* This class is used for the Variable Neighborhood Search explorer inherits from moVectorVNSelection
* The search heuristics are saved in vectors
* They are given in random order (at each initialization the order is changed)
*
*/
template< class EOT >
class moRndVectorVNSelection: public moVectorVNSelection<EOT>
{
using moVectorVNSelection<EOT>::LSvector;
using moVectorVNSelection<EOT>::current;
public:
/**
* Default constructor with first search heuristics
*
* @param _firstLS first local search
* @param _firstShake first heuristic which perturbs the solution
* @param _cycle when true, the first heuristics follows the last ones. Otherwise the search stop.
*/
moRndVectorVNSelection(eoMonOp<EOT>& _firstLS, eoMonOp<EOT>& _firstShake, bool _cycle = true) : moVectorVNSelection<EOT>(_firstLS, _firstShake), cycle(_cycle){}
/**
* Return the class id.
* @return the class name as a std::string
*/
virtual std::string className() const {
return "moRndVectorVNSelection";
}
/**
* test if there is still some heuristics
*
* @param _solution the current solution
* @return true if there is some heuristics
*/
virtual bool cont(EOT& _solution){
return ( cycle || (currentOrder <= (order.size() - 2)) );
}
/**
* put the current heuristics on the first ones
*
* @param _solution the current solution
*/
virtual void init(EOT& _solution) {
if(order.size() == 0)
for(unsigned int i = 0; i < LSvector.size(); i++)
order.push_back(i);
std::random_shuffle(order.begin(), order.end(), gen);
currentOrder = 0;
current = order[currentOrder];
}
/**
* put the current heuristics on the next ones
*
* @param _solution the current solution
*/
virtual void next(EOT& _solution){
currentOrder = (currentOrder + 1) % order.size();
current = order[currentOrder];
}
private:
// boolean to indicate the first heuristics follow the last ones
bool cycle;
// index in order vector
unsigned int currentOrder;
// the index of heuristics in random order
std::vector<unsigned int> order;
// random generator
UF_random_generator<unsigned int> gen;
};
#endif

109
tags/ParadisEO-GPU-1.1/paradiseo-mo/src/neighborhood/moRndWithReplNeighborhood.h
View file

@ -1,109 +0,0 @@
/*
<moRndWithReplNeighborhood.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 _moRndWithReplNeighborhood_h
#define _moRndWithReplNeighborhood_h
#include <neighborhood/moIndexNeighborhood.h>
#include <neighborhood/moRndNeighborhood.h>
#include <utils/eoRNG.h>
/**
* A Random With replacement Neighborhood
*/
template< class Neighbor >
class moRndWithReplNeighborhood : public moIndexNeighborhood<Neighbor>, public moRndNeighborhood<Neighbor>
{
public:
/**
* Define type of a solution corresponding to Neighbor
*/
typedef typename Neighbor::EOT EOT;
using moIndexNeighborhood<Neighbor>::neighborhoodSize;
/**
* Constructor
* @param _neighborhoodSize the size of the neighborhood
*/
moRndWithReplNeighborhood(unsigned int _neighborhoodSize): moIndexNeighborhood<Neighbor>(_neighborhoodSize) {}
/**
* Test if it exist a neighbor
* @param _solution the solution to explore
* @return true if the neighborhood was not empty
*/
virtual bool hasNeighbor(EOT& _solution) {
return neighborhoodSize > 0;
}
/**
* Initialization of the neighborhood
* @param _solution the solution to explore
* @param _neighbor the first neighbor
*/
virtual void init(EOT & _solution, Neighbor & _neighbor) {
_neighbor.index(rng.random(neighborhoodSize));
}
/**
* Give the next neighbor
* @param _solution the solution to explore
* @param _neighbor the next neighbor
*/
virtual void next(EOT & _solution, Neighbor & _neighbor) {
_neighbor.index(rng.random(neighborhoodSize));
}
/**
* test if all neighbors are explore or not,if false, there is no neighbor left to explore
* @param _solution the solution to explore
* @return true if there is again a neighbor to explore
*/
virtual bool cont(EOT & _solution) {
return neighborhoodSize > 0;
}
/**
* Return the class Name
* @return the class name as a std::string
*/
virtual std::string className() const {
return "moRndWithReplNeighborhood";
}
};
#endif

138
tags/ParadisEO-GPU-1.1/paradiseo-mo/src/neighborhood/moRndWithoutReplNeighborhood.h
View file

@ -1,138 +0,0 @@
/*
<moRndWithoutReplNeighborhood.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 _moRndWithoutReplNeighborhood_h
#define _moRndWithoutReplNeighborhood_h
#include <neighborhood/moIndexNeighborhood.h>
#include <neighborhood/moRndNeighborhood.h>
#include <utils/eoRNG.h>
/**
* A Random without replacement Neighborhood
*/
template< class Neighbor >
class moRndWithoutReplNeighborhood : public moIndexNeighborhood<Neighbor>, public moRndNeighborhood<Neighbor>
{
public:
/**
* Define type of a solution corresponding to Neighbor
*/
typedef typename Neighbor::EOT EOT;
using moIndexNeighborhood<Neighbor>::neighborhoodSize;
/**
* Constructor
* @param _neighborhoodSize the size of the neighborhood
*/
moRndWithoutReplNeighborhood(unsigned int _neighborhoodSize): moIndexNeighborhood<Neighbor>(_neighborhoodSize), maxIndex(0) {
for (unsigned int i=0; i < neighborhoodSize; i++)
indexVector.push_back(i);
}
/**
* Test if it exist a neighbor
* @param _solution the solution to explore
* @return true if the neighborhood was not empty
*/
virtual bool hasNeighbor(EOT& _solution) {
return neighborhoodSize > 0;
}
/**
* Initialization of the neighborhood
* @param _solution the solution to explore
* @param _neighbor the first neighbor
*/
virtual void init(EOT & _solution, Neighbor & _neighbor) {
unsigned int i, tmp;
maxIndex = neighborhoodSize ;
i = rng.random(maxIndex);
_neighbor.index(indexVector[i]);
tmp=indexVector[i];
indexVector[i]=indexVector[maxIndex-1];
indexVector[maxIndex-1]=tmp;
maxIndex--;
}
/**
* Give the next neighbor
* @param _solution the solution to explore
* @param _neighbor the next neighbor
*/
virtual void next(EOT & _solution, Neighbor & _neighbor) {
unsigned int i, tmp;
i = rng.random(maxIndex);
_neighbor.index(indexVector[i]);
tmp=indexVector[i];
indexVector[i]=indexVector[maxIndex-1];
indexVector[maxIndex-1]=tmp;
maxIndex--;
}
/**
* test if all neighbors are explore or not,if false, there is no neighbor left to explore
* maxIndex is number of neighbors
* @param _solution the solution to explore
* @return true if there is again a neighbor to explore
*/
virtual bool cont(EOT & _solution) {
return (maxIndex > 0) ;
}
/**
* Getter
* @return the position in the Neighborhood
*/
unsigned int position() {
return indexVector[maxIndex];
}
/**
* Return the class Name
* @return the class name as a std::string
*/
virtual std::string className() const {
return "moRndWithoutReplNeighborhood";
}
private:
unsigned int maxIndex;
std::vector<unsigned int> indexVector;
};
#endif

88
tags/ParadisEO-GPU-1.1/paradiseo-mo/src/neighborhood/moVariableNeighborhoodSelection.h
View file

@ -1,88 +0,0 @@
/*
<moVariableNeighborhoodSelection.h>
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 ue,
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".
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 _moVariableNeighborhoodSelection_h
#define _moVariableNeighborhoodSelection_h
#include <eoOp.h>
#include <vector>
/**
* This class is used for the Variable Neighborhood Search explorer
* It gives the sequence of search heuristics based on the different "neighborhoods"
* The class is built such as the moNeighborhood" with init, next, cont
* and two methods to get the heuristics which shake the solution, and which give the local search
*
*/
template< class EOT >
class moVariableNeighborhoodSelection
{
public:
/**
* Return the class id.
* @return the class name as a std::string
*/
virtual std::string className() const {
return "moVariableNeighborhoodSelection";
}
/**
* test if there is still some search heuristics to use
* @return true if there is some neighborhood to explore
*/
virtual bool cont(EOT& _solution) = 0;
/**
* put on the first search heuristics
*/
virtual void init(EOT& _solution) = 0;
/**
* put the next search heuristics
*/
virtual void next(EOT& _solution) = 0;
/**
* Get the current "shake" operator based on the current neighborhood
*
* @return current shake operator
*/
virtual eoMonOp<EOT> & getShake() = 0;
/**
* Get the current local search based on the current neighborhood
*
* @return current local search
*/
virtual eoMonOp<EOT> & getLocalSearch() = 0;
};
#endif

108
tags/ParadisEO-GPU-1.1/paradiseo-mo/src/neighborhood/moVectorVNSelection.h
View file

@ -1,108 +0,0 @@
/*
<moVectorVNSelection.h>
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 ue,
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".
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 _moVectorVNSelection_h
#define _moVectorVNSelection_h
#include <neighborhood/moVariableNeighborhoodSelection.h>
#include <eoOp.h>
/**
* This class is used for the Variable Neighborhood Search explorer inherits from moVariableNeighborhoodSelection
* The search heuristics are saved in vectors
* The way to croos the vector is not defined here
*
*/
template< class EOT >
class moVectorVNSelection: public moVariableNeighborhoodSelection<EOT>{
public:
/**
* Default constructor with first search heuristics
*
* @param _firstLS first local search
* @param _firstShake first heuristic which perturbs the solution
*/
moVectorVNSelection(eoMonOp<EOT>& _firstLS, eoMonOp<EOT>& _firstShake){
LSvector.push_back(&_firstLS);
shakeVector.push_back(&_firstShake);
current = 0;
}
/**
* Add some search heuristics
*
* @param _otherLS the added local search
* @param _otherShake the added heuristic which perturbs the solution
*/
void add(eoMonOp<EOT>& _otherLS, eoMonOp<EOT>& _otherShake){
LSvector.push_back(&_otherLS);
shakeVector.push_back(&_otherShake);
}
/**
* Return the class id.
* @return the class name as a std::string
*/
virtual std::string className() const {
return "moVectorVNSelection";
}
/**
* Get the current "shake" operator based on the current neighborhood
*
* @return current shake operator
*/
virtual eoMonOp<EOT> & getShake() {
return *(shakeVector[current]);
}
/**
* Get the current local search based on the current neighborhood
*
* @return current local search
*/
virtual eoMonOp<EOT> & getLocalSearch() {
return *(LSvector[current]);
}
protected:
// vector of local searches
std::vector<eoMonOp<EOT>* > LSvector;
// vector of "shake" heiristics which perturbs the current solution
std::vector<eoMonOp<EOT>* > shakeVector;
// index of the current search heuristics which is applied
unsigned int current;
};
#endif

66
tags/ParadisEO-GPU-1.1/paradiseo-mo/src/perturb/moLocalSearchInit.h
View file

@ -1,66 +0,0 @@
/*
<moLocalSearchInit.h>
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 ue,
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".
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 _moLocalSearchInit_h
#define _moLocalSearchInit_h
#include <eoInit.h>
#include <algo/moLocalSearch.h>
/**
* Initialization of the solution with a local search
*/
template< class Neighbor >
class moLocalSearchInit : public eoInit<typename Neighbor::EOT> {
public:
typedef typename Neighbor::EOT EOT;
/**
* Constructor
* @param _init initialization of the solution before the local search
* @param _ls the local search to apply to the solution
*/
moLocalSearchInit(eoInit<EOT>& _init, moLocalSearch<Neighbor>& _ls) : init(_init), ls(_ls) {
}
/**
* Apply the local search on the solution
* @param _solution to perturb
*/
void operator()(EOT& _solution) {
init(_solution);
ls(_solution);
}
private:
eoInit<EOT>& init;
moLocalSearch<Neighbor> & ls;
};
#endif

72
tags/ParadisEO-GPU-1.1/paradiseo-mo/src/perturb/moMonOpPerturb.h
View file

@ -1,72 +0,0 @@
/*
<moMonOpPerturb.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 ue,
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".
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 _moMonOpPerturb_h
#define _moMonOpPerturb_h
#include <eoEvalFunc.h>
#include <eoOp.h>
#include <perturb/moPerturbation.h>
#include <memory/moDummyMemory.h>
/**
* Perturbation operator using only a eoMonOp
*/
template< class Neighbor >
class moMonOpPerturb : public moPerturbation<Neighbor>, public moDummyMemory<Neighbor> {
public:
typedef typename Neighbor::EOT EOT;
/**
* Constructor
* @param _monOp an eoMonOp (pertubation operator)
* @param _fullEval a full evaluation function
*/
moMonOpPerturb(eoMonOp<EOT>& _monOp, eoEvalFunc<EOT>& _fullEval):monOp(_monOp), fullEval(_fullEval) {}
/**
* Apply monOp on the solution
* @param _solution to perturb
* @return value of monOp
*/
bool operator()(EOT& _solution) {
bool res = monOp(_solution);
_solution.invalidate();
fullEval(_solution);
return res;
}
private:
/** monOp */
eoMonOp<EOT>& monOp;
eoEvalFunc<EOT>& fullEval;
};
#endif

109
tags/ParadisEO-GPU-1.1/paradiseo-mo/src/perturb/moNeighborhoodPerturb.h
View file

@ -1,109 +0,0 @@
/*
<moNeighborhoodPerturb.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 ue,
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".
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 _moNeighborhoodPerturb_h
#define _moNeighborhoodPerturb_h
#include <eval/moEval.h>
#include <perturb/moPerturbation.h>
#include <neighborhood/moNeighborhood.h>
/**
* Neighborhood Perturbation: explore the neighborhood to perturb the solution (the neighborhood could be different as the one used in the Local Search)
*/
template< class Neighbor, class OtherNeighbor >
class moNeighborhoodPerturb : public moPerturbation<Neighbor> {
public:
typedef typename Neighbor::EOT EOT;
typedef moNeighborhood<OtherNeighbor> OtherNH;
/**
* Constructor
* @param _otherNeighborhood a neighborhood
* @param _eval an Evaluation Function
*/
moNeighborhoodPerturb(OtherNH& _otherNeighborhood, moEval<OtherNeighbor>& _eval): otherNeighborhood(_otherNeighborhood), eval(_eval) {}
/**
* Apply move on the solution
* @param _solution the current solution
* @return true
*/
virtual bool operator()(EOT& _solution) {
if (otherNeighborhood.hasNeighbor(_solution)) {
eval(_solution, current);
current.move(_solution);
_solution.fitness(current.fitness());
}
return true;
}
/**
* Init the neighborhood
* @param _sol the current solution
*/
virtual void init(EOT & _sol) {
if (otherNeighborhood.hasNeighbor(_sol))
otherNeighborhood.init(_sol, current);
}
/**
* ReInit the neighborhood because a move was done
* @param _sol the current solution
* @param _neighbor unused neighbor (always empty)
*/
virtual void add(EOT & _sol, Neighbor & _neighbor) {
(*this).init(_sol);
}
/**
* Explore another neighbor because no move was done
* @param _sol the current solution
* @param _neighbor unused neighbor (always empty)
*/
virtual void update(EOT & _sol, Neighbor & _neighbor) {
if (otherNeighborhood.cont(_sol))
otherNeighborhood.next(_sol, current);
else
(*this).init(_sol);
}
/**
* NOTHING TO DO
*/
virtual void clearMemory() {}
private:
OtherNH& otherNeighborhood;
moEval<OtherNeighbor>& eval;
OtherNeighbor current;
};
#endif

42
tags/ParadisEO-GPU-1.1/paradiseo-mo/src/perturb/moPerturbation.h
View file

@ -1,42 +0,0 @@
/*
<moPertubation.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 ue,
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".
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 _moPertubation_h
#define _moPertubation_h
#include <eoOp.h>
#include <memory/moMemory.h>
/**
* Abstract class for Perturbation operator
*/
template< class Neighbor >
class moPerturbation : public eoMonOp<typename Neighbor::EOT>, virtual public moMemory<Neighbor> {};
#endif

77
tags/ParadisEO-GPU-1.1/paradiseo-mo/src/perturb/moRestartPerturb.h
View file

@ -1,77 +0,0 @@
/*
<moRestartPerturb.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 ue,
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".
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 _moRestartPerturb_h
#define _moRestartPerturb_h
#include <eoEvalFunc.h>
#include <eoInit.h>
#include <perturb/moPerturbation.h>
#include <memory/moCountMoveMemory.h>
/**
* Restart Perturbation : restart when maximum number of iteration with no improvement is reached
*/
template< class Neighbor >
class moRestartPerturb : public moPerturbation<Neighbor>, public moCountMoveMemory<Neighbor> {
public:
typedef typename Neighbor::EOT EOT;
/**
* Constructor
* @param _initializer an initializer of solution
* @param _fullEval a full evaluation function
* @param _threshold maximum number of iteration with no improvement
*/
moRestartPerturb(eoInit<EOT>& _initializer, eoEvalFunc<EOT>& _fullEval, unsigned int _threshold):initializer(_initializer), fullEval(_fullEval), threshold(_threshold) {}
/**
* Apply restart when necessary
* @param _solution to restart
* @return true
*/
bool operator()(EOT& _solution) {
if ((*this).getCounter()>= threshold) {
initializer(_solution);
fullEval(_solution);
(*this).initCounter();
}
return true;
}
private:
eoInit<EOT>& initializer;
eoEvalFunc<EOT>& fullEval;
unsigned int threshold;
};
#endif

60
tags/ParadisEO-GPU-1.1/paradiseo-mo/src/perturb/moSolInit.h
View file

@ -1,60 +0,0 @@
/*
<moSolInit.h>
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 ue,
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".
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 _moSolInit_h
#define _moSolInit_h
#include <eoInit.h>
/**
* Initialization of the solution with the external solution
*/
template< class EOT >
class moSolInit : public eoInit<EOT> {
public:
/**
* Constructor
* @param _extSol external solution of the initialization
*/
moSolInit(EOT & _extSol) : extSol(_extSol) {}
/**
* Initialization on the external solution
* @param _solution to initialize
*/
void operator()(EOT& _solution) {
_solution = extSol;
}
private:
EOT& extSol;
};
#endif

110
tags/ParadisEO-GPU-1.1/paradiseo-mo/src/sampling/moAdaptiveWalkSampling.h
View file

@ -1,110 +0,0 @@
/*
<moAdaptiveWalkSampling.h>
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 moAdaptiveWalkSampling_h
#define moAdaptiveWalkSampling_h
#include <eoInit.h>
#include <eval/moEval.h>
#include <eoEvalFunc.h>
#include <continuator/moCheckpoint.h>
#include <perturb/moLocalSearchInit.h>
#include <algo/moRandomSearch.h>
#include <algo/moFirstImprHC.h>
#include <continuator/moSolutionStat.h>
#include <continuator/moMinusOneCounterStat.h>
#include <continuator/moStatFromStat.h>
#include <sampling/moSampling.h>
/**
* To compute the length and final solution of an adaptive walk:
* Perform a first improvement Hill-climber based on the neighborhood (adaptive walk),
* The lengths of HC are collected and the final solution which are local optima
* The adaptive walk is repeated several times
*
*/
template <class Neighbor>
class moAdaptiveWalkSampling : public moSampling<Neighbor>
{
public:
typedef typename Neighbor::EOT EOT ;
using moSampling<Neighbor>::localSearch;
/**
* Constructor
* @param _init initialisation method of the solution
* @param _neighborhood neighborhood giving neighbor in random order
* @param _fullEval a full evaluation function
* @param _eval an incremental evaluation of neighbors
* @param _nbAdaptWalk Number of adaptive walks
*/
moAdaptiveWalkSampling(eoInit<EOT> & _init,
moNeighborhood<Neighbor> & _neighborhood,
eoEvalFunc<EOT>& _fullEval,
moEval<Neighbor>& _eval,
unsigned int _nbAdaptWalk) :
moSampling<Neighbor>(initHC, * new moRandomSearch<Neighbor>(initHC, _fullEval, _nbAdaptWalk), copyStat),
copyStat(lengthStat),
checkpoint(trueCont),
hc(_neighborhood, _fullEval, _eval, checkpoint),
initHC(_init, hc)
{
// to count the number of step in the HC
checkpoint.add(lengthStat);
// add the solution into statistics
add(solStat);
}
/**
* Destructor
*/
~moAdaptiveWalkSampling() {
// delete the pointer on the local search which has been constructed in the constructor
delete localSearch;
}
protected:
moSolutionStat<EOT> solStat;
moMinusOneCounterStat<EOT> lengthStat;
moTrueContinuator<Neighbor> trueCont;
moStatFromStat<EOT, unsigned int> copyStat;
moCheckpoint<Neighbor> checkpoint;
moFirstImprHC<Neighbor> hc;
moLocalSearchInit<Neighbor> initHC;
};
#endif

89
tags/ParadisEO-GPU-1.1/paradiseo-mo/src/sampling/moAutocorrelationSampling.h
View file

@ -1,89 +0,0 @@
/*
<moAutocorrelationSampling.h>
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 moAutocorrelationSampling_h
#define moAutocorrelationSampling_h
#include <eoInit.h>
#include <eval/moEval.h>
#include <eoEvalFunc.h>
#include <algo/moRandomWalk.h>
#include <continuator/moFitnessStat.h>
#include <sampling/moSampling.h>
/**
* To compute the autocorrelation function:
* Perform a random walk based on the neighborhood,
* The fitness values of solutions are collected during the random walk
* The autocorrelation can be computed from the serie of fitness values
*
*/
template <class Neighbor>
class moAutocorrelationSampling : public moSampling<Neighbor>
{
public:
typedef typename Neighbor::EOT EOT ;
using moSampling<Neighbor>::localSearch;
/**
* Constructor
* @param _init initialisation method of the solution
* @param _neighborhood neighborhood giving neighbor in random order
* @param _fullEval Fitness function, full evaluation function
* @param _eval neighbor evaluation, incremental evaluation function
* @param _nbStep Number of steps of the random walk
*/
moAutocorrelationSampling(eoInit<EOT> & _init,
moNeighborhood<Neighbor> & _neighborhood,
eoEvalFunc<EOT>& _fullEval,
moEval<Neighbor>& _eval,
unsigned int _nbStep) :
moSampling<Neighbor>(_init, * new moRandomWalk<Neighbor>(_neighborhood, _fullEval, _eval, _nbStep), fitnessStat) {}
/**
* Destructor
*/
~moAutocorrelationSampling() {
// delete the pointer on the local search which has been constructed in the constructor
delete localSearch;
}
protected:
moFitnessStat<EOT> fitnessStat;
};
#endif

83
tags/ParadisEO-GPU-1.1/paradiseo-mo/src/sampling/moDensityOfStatesSampling.h
View file

@ -1,83 +0,0 @@
/*
<moDensityOfStatesSampling.h>
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 moDensityOfStatesSampling_h
#define moDensityOfStatesSampling_h
#include <eoInit.h>
#include <eoEvalFunc.h>
#include <algo/moRandomSearch.h>
#include <continuator/moFitnessStat.h>
#include <sampling/moSampling.h>
/**
* To compute the density of states:
* Sample the fitness of random solution in the search space
* The fitness values of solutions are collected during the random search
*
*/
template <class Neighbor>
class moDensityOfStatesSampling : public moSampling<Neighbor>
{
public:
typedef typename Neighbor::EOT EOT ;
using moSampling<Neighbor>::localSearch;
/**
* Constructor
* @param _init initialisation method of the solution
* @param _fullEval Fitness function, full evaluation function
* @param _nbSol Number of solutions in the sample
*/
moDensityOfStatesSampling(eoInit<EOT> & _init,
eoEvalFunc<EOT>& _fullEval,
unsigned int _nbSol) :
moSampling<Neighbor>(_init, * new moRandomSearch<Neighbor>(_init, _fullEval, _nbSol), fitnessStat) {}
/**
* default destructor
*/
~moDensityOfStatesSampling() {
// delete the pointer on the local search which has been constructed in the constructor
delete localSearch;
}
protected:
moFitnessStat<EOT> fitnessStat;
};
#endif

95
tags/ParadisEO-GPU-1.1/paradiseo-mo/src/sampling/moFDCsampling.h
View file

@ -1,95 +0,0 @@
/*
<moFDCsampling.h>
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 moFDCsampling_h
#define moFDCsampling_h
#include <eoInit.h>
#include <eval/moEval.h>
#include <eoEvalFunc.h>
#include <algo/moRandomSearch.h>
#include <continuator/moFitnessStat.h>
#include <utils/eoDistance.h>
#include <continuator/moDistanceStat.h>
#include <sampling/moSampling.h>
/**
* To compute the fitness distance correlation:
* Sample the fitness and the distance from a particular solution of random solution in the search space
* The fitness values and distances of solutions are collected during the random search
* Then the correlation between the fitness and the distance can be computed
*
*/
template <class Neighbor>
class moFDCsampling : public moSampling<Neighbor>
{
public:
typedef typename Neighbor::EOT EOT ;
using moSampling<Neighbor>::localSearch;
/**
* Constructor
* @param _init initialisation method of the solution
* @param _fullEval a full evaluation function
* @param _dist the distance function between solution
* @param _refSol the reference solution to compute the distance (think of global optimum when possible)
* @param _nbSol Number of solutions of the sample
*/
moFDCsampling(eoInit<EOT> & _init,
eoEvalFunc<EOT>& _fullEval,
eoDistance<EOT>& _dist,
EOT& _refSol,
unsigned int _nbSol) :
moSampling<Neighbor>(_init, * new moRandomSearch<Neighbor>(_init, _fullEval, _nbSol), fitnessStat),
distStat(_dist, _refSol)
{
add(distStat);
}
/**
* Destructor
*/
~moFDCsampling() {
// delete the pointer on the local search which has been constructed in the constructor
delete localSearch;
}
protected:
moFitnessStat<EOT> fitnessStat;
moDistanceStat<EOT> distStat;
};
#endif

100
tags/ParadisEO-GPU-1.1/paradiseo-mo/src/sampling/moFitnessCloudSampling.h
View file

@ -1,100 +0,0 @@
/*
<moFitnessCloudSampling.h>
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 moFitnessCloudSampling_h
#define moFitnessCloudSampling_h
#include <eoInit.h>
#include <neighborhood/moNeighborhood.h>
#include <eval/moEval.h>
#include <eoEvalFunc.h>
#include <algo/moDummyLS.h>
#include <continuator/moFitnessStat.h>
#include <continuator/moNeighborFitnessStat.h>
#include <sampling/moSampling.h>
/**
* To compute an estimation of the fitness cloud,
* i.e. the scatter plot of solution fitness versus neighbor fitness:
*
* This class do nothing. See others mo(...)FitnessCloudSampling classes
* with different fitness sampling methods
*/
template <class Neighbor>
class moFitnessCloudSampling : public moSampling<Neighbor>
{
public:
typedef typename Neighbor::EOT EOT ;
using moSampling<Neighbor>::localSearch;
/**
* Constructor
* @param _init initialisation method of the solution
* @param _neighborhood neighborhood to get a neighbor
* @param _fullEval Fitness function, full evaluation function
* @param _eval neighbor evaluation, incremental evaluation function
* @param _nbSol Number of solutions in the sample
*/
moFitnessCloudSampling(eoInit<EOT> & _init,
moNeighborhood<Neighbor> & _neighborhood,
eoEvalFunc<EOT>& _fullEval,
moEval<Neighbor>& _eval,
unsigned int _nbSol) :
moSampling<Neighbor>(_init, * new moDummyLS<Neighbor>(_fullEval), fitnessStat),
neighborhood(_neighborhood),
fullEval(_fullEval),
eval(_eval),
nbSol(_nbSol)
{}
/**
* default destructor
*/
~moFitnessCloudSampling() {
// delete the pointer on the local search which has been constructed in the constructor
delete localSearch;
}
protected:
moNeighborhood<Neighbor> & neighborhood;
eoEvalFunc<EOT>& fullEval;
moEval<Neighbor>& eval;
unsigned int nbSol;
moFitnessStat<EOT> fitnessStat;
};
#endif

110
tags/ParadisEO-GPU-1.1/paradiseo-mo/src/sampling/moHillClimberSampling.h
View file

@ -1,110 +0,0 @@
/*
<moHillClimberSampling.h>
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 moHillClimberSampling_h
#define moHillClimberSampling_h
#include <eoInit.h>
#include <eval/moEval.h>
#include <eoEvalFunc.h>
#include <continuator/moCheckpoint.h>
#include <perturb/moLocalSearchInit.h>
#include <algo/moRandomSearch.h>
#include <algo/moSimpleHC.h>
#include <continuator/moSolutionStat.h>
#include <continuator/moMinusOneCounterStat.h>
#include <continuator/moStatFromStat.h>
#include <sampling/moSampling.h>
/**
* To compute the length and final solution of an adaptive walk:
* Perform a simple Hill-climber based on the neighborhood (gradiant walk, the whole neighborhood is visited),
* The lengths of HC are collected and the final solution which are local optima
* The adaptive walk is repeated several times
*
*/
template <class Neighbor>
class moHillClimberSampling : public moSampling<Neighbor>
{
public:
typedef typename Neighbor::EOT EOT ;
using moSampling<Neighbor>::localSearch;
/**
* Constructor
* @param _init initialisation method of the solution
* @param _neighborhood neighborhood giving neighbor in random order
* @param _fullEval a full evaluation function
* @param _eval an incremental evaluation of neighbors
* @param _nbAdaptWalk Number of adaptive walks
*/
moHillClimberSampling(eoInit<EOT> & _init,
moNeighborhood<Neighbor> & _neighborhood,
eoEvalFunc<EOT>& _fullEval,
moEval<Neighbor>& _eval,
unsigned int _nbAdaptWalk) :
moSampling<Neighbor>(initHC, * new moRandomSearch<Neighbor>(initHC, _fullEval, _nbAdaptWalk), copyStat),
copyStat(lengthStat),
checkpoint(trueCont),
hc(_neighborhood, _fullEval, _eval, checkpoint),
initHC(_init, hc)
{
// to count the number of step in the HC
checkpoint.add(lengthStat);
// add the solution into statistics
add(solStat);
}
/**
* Destructor
*/
~moHillClimberSampling() {
// delete the pointer on the local search which has been constructed in the constructor
delete localSearch;
}
protected:
moSolutionStat<EOT> solStat;
moMinusOneCounterStat<EOT> lengthStat;
moTrueContinuator<Neighbor> trueCont;
moStatFromStat<EOT, unsigned int> copyStat;
moCheckpoint<Neighbor> checkpoint;
moSimpleHC<Neighbor> hc;
moLocalSearchInit<Neighbor> initHC;
};
#endif

113
tags/ParadisEO-GPU-1.1/paradiseo-mo/src/sampling/moMHBestFitnessCloudSampling.h
View file

@ -1,113 +0,0 @@
/*
<moMHBestFitnessCloudSampling.h>
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 moMHBestFitnessCloudSampling_h
#define moMHBestFitnessCloudSampling_h
#include <eoInit.h>
#include <neighborhood/moNeighborhood.h>
#include <eval/moEval.h>
#include <eoEvalFunc.h>
#include <algo/moMetropolisHasting.h>
#include <continuator/moNeighborBestStat.h>
#include <sampling/moFitnessCloudSampling.h>
/**
* To compute an estimation of the fitness cloud,
* i.e. the scatter plot of solution fitness versus neighbor fitness:
*
* Here solution are sampled with Metropolis-Hasting method
*
* Sample the fitness of solutions from Metropolis-Hasting sampling
* and the best fitness of k random neighbor
*
* The values are collected during the Metropolis-Hasting walk
*
*/
template <class Neighbor>
class moMHBestFitnessCloudSampling : public moFitnessCloudSampling<Neighbor>
{
public:
typedef typename Neighbor::EOT EOT ;
using moSampling<Neighbor>::localSearch;
using moSampling<Neighbor>::checkpoint;
using moSampling<Neighbor>::monitorVec;
using moSampling<Neighbor>::continuator;
using moFitnessCloudSampling<Neighbor>::fitnessStat;
/**
* Constructor
* @param _init initialisation method of the solution
* @param _neighborhood neighborhood to get one random neighbor (supposed to be random neighborhood)
* @param _fullEval Fitness function, full evaluation function
* @param _eval neighbor evaluation, incremental evaluation function
* @param _nbStep Number of step of the MH sampling
*/
moMHBestFitnessCloudSampling(eoInit<EOT> & _init,
moNeighborhood<Neighbor> & _neighborhood,
eoEvalFunc<EOT>& _fullEval,
moEval<Neighbor>& _eval,
unsigned int _nbStep) :
moFitnessCloudSampling<Neighbor>(_init, _neighborhood, _fullEval, _eval, _nbStep),
neighborBestStat(_neighborhood, _eval)
{
// delete the dummy local search
delete localSearch;
// Metropolis-Hasting sampling
localSearch = new moMetropolisHasting<Neighbor>(_neighborhood, _fullEval, _eval, _nbStep);
// delete the checkpoint with the wrong continuator
delete checkpoint;
// set the continuator
continuator = localSearch->getContinuator();
// re-construction of the checkpoint
checkpoint = new moCheckpoint<Neighbor>(*continuator);
checkpoint->add(fitnessStat);
checkpoint->add(*monitorVec[0]);
// one random neighbor
add(neighborBestStat);
}
protected:
moNeighborBestStat< Neighbor > neighborBestStat;
};
#endif

113
tags/ParadisEO-GPU-1.1/paradiseo-mo/src/sampling/moMHRndFitnessCloudSampling.h
View file

@ -1,113 +0,0 @@
/*
<moMHRndFitnessCloudSampling.h>
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 moMHRndFitnessCloudSampling_h
#define moMHRndFitnessCloudSampling_h
#include <eoInit.h>
#include <neighborhood/moNeighborhood.h>
#include <eval/moEval.h>
#include <eoEvalFunc.h>
#include <algo/moMetropolisHasting.h>
#include <continuator/moNeighborFitnessStat.h>
#include <sampling/moFitnessCloudSampling.h>
/**
* To compute an estimation of the fitness cloud,
* i.e. the scatter plot of solution fitness versus neighbor fitness:
*
* Here solution are sampled with Metropolis-Hasting method
*
* Sample the fitness of solutions from Metropolis-Hasting sampling
* and the fitness of one random neighbor
*
* The values are collected during the Metropolis-Hasting walk
*
*/
template <class Neighbor>
class moMHRndFitnessCloudSampling : public moFitnessCloudSampling<Neighbor>
{
public:
typedef typename Neighbor::EOT EOT ;
using moSampling<Neighbor>::localSearch;
using moSampling<Neighbor>::checkpoint;
using moSampling<Neighbor>::monitorVec;
using moSampling<Neighbor>::continuator;
using moFitnessCloudSampling<Neighbor>::fitnessStat;
/**
* Constructor
* @param _init initialisation method of the solution
* @param _neighborhood neighborhood to get one random neighbor (supposed to be random neighborhood)
* @param _fullEval Fitness function, full evaluation function
* @param _eval neighbor evaluation, incremental evaluation function
* @param _nbStep Number of step of the MH sampling
*/
moMHRndFitnessCloudSampling(eoInit<EOT> & _init,
moNeighborhood<Neighbor> & _neighborhood,
eoEvalFunc<EOT>& _fullEval,
moEval<Neighbor>& _eval,
unsigned int _nbStep) :
moFitnessCloudSampling<Neighbor>(_init, _neighborhood, _fullEval, _eval, _nbStep),
neighborFitnessStat(_neighborhood, _eval)
{
// delete the dummy local search
delete localSearch;
// Metropolis-Hasting sampling
localSearch = new moMetropolisHasting<Neighbor>(_neighborhood, _fullEval, _eval, _nbStep);
// delete the checkpoint with the wrong continuator
delete checkpoint;
// set the continuator
continuator = localSearch->getContinuator();
// re-construction of the checkpoint
checkpoint = new moCheckpoint<Neighbor>(*continuator);
checkpoint->add(fitnessStat);
checkpoint->add(*monitorVec[0]);
// one random neighbor
add(neighborFitnessStat);
}
protected:
moNeighborFitnessStat< Neighbor > neighborFitnessStat;
};
#endif

125
tags/ParadisEO-GPU-1.1/paradiseo-mo/src/sampling/moNeutralDegreeSampling.h
View file

@ -1,125 +0,0 @@
/*
<moNeutralDegreeSampling.h>
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 moNeutralDegreeSampling_h
#define moNeutralDegreeSampling_h
#include <eoInit.h>
#include <neighborhood/moNeighborhood.h>
#include <eval/moEval.h>
#include <eoEvalFunc.h>
#include <algo/moRandomSearch.h>
#include <continuator/moFitnessStat.h>
#include <continuator/moNeighborhoodStat.h>
#include <continuator/moNeutralDegreeNeighborStat.h>
#include <sampling/moSampling.h>
/**
* To compute the neutral degree:
* Sample the fitness of random solution in the search space (1er information)
* and sample the neutral degree (2nd information), i.e. the number of neighbor solutions with the same fitness value
* The values are collected during the random search
*
*/
template <class Neighbor>
class moNeutralDegreeSampling : public moSampling<Neighbor>
{
public:
typedef typename Neighbor::EOT EOT ;
using moSampling<Neighbor>::localSearch;
/**
* Constructor
* @param _init initialisation method of the solution
* @param _neighborhood neighborhood to compute the neutral degree
* @param _fullEval Fitness function, full evaluation function
* @param _eval neighbor evaluation, incremental evaluation function
* @param _nbSol Number of solutions in the sample
*/
moNeutralDegreeSampling(eoInit<EOT> & _init,
moNeighborhood<Neighbor> & _neighborhood,
eoEvalFunc<EOT>& _fullEval,
moEval<Neighbor>& _eval,
unsigned int _nbSol) :
moSampling<Neighbor>(_init, * new moRandomSearch<Neighbor>(_init, _fullEval, _nbSol), fitnessStat),
neighborhoodStat(_neighborhood, _eval),
ndStat(neighborhoodStat)
{
add(neighborhoodStat, false);
add(ndStat);
}
/**
* Constructor with comparators
* @param _init initialisation method of the solution
* @param _neighborhood neighborhood to compute the neutral degree
* @param _fullEval Fitness function, full evaluation function
* @param _eval neighbor evaluation, incremental evaluation function
* @param _neighborComparator a neighbor Comparator
* @param _solNeighborComparator a comparator between a solution and a neighbor
* @param _nbSol Number of solutions in the sample
*/
moNeutralDegreeSampling(eoInit<EOT> & _init,
moNeighborhood<Neighbor> & _neighborhood,
eoEvalFunc<EOT>& _fullEval,
moEval<Neighbor>& _eval,
moNeighborComparator<Neighbor>& _neighborComparator,
moSolNeighborComparator<Neighbor>& _solNeighborComparator,
unsigned int _nbSol) :
moSampling<Neighbor>(_init, * new moRandomSearch<Neighbor>(_init, _fullEval, _nbSol), fitnessStat),
neighborhoodStat(_neighborhood, _eval, _neighborComparator, _solNeighborComparator),
ndStat(neighborhoodStat)
{
add(neighborhoodStat, false);
add(ndStat);
}
/**
* default destructor
*/
~moNeutralDegreeSampling() {
// delete the pointer on the local search which has been constructed in the constructor
delete localSearch;
}
protected:
moFitnessStat<EOT> fitnessStat;
moNeighborhoodStat< Neighbor > neighborhoodStat;
moNeutralDegreeNeighborStat< Neighbor > ndStat;
};
#endif

148
tags/ParadisEO-GPU-1.1/paradiseo-mo/src/sampling/moNeutralWalkSampling.h
View file

@ -1,148 +0,0 @@
/*
<moNeutralWalkSampling.h>
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 moNeutralWalkSampling_h
#define moNeutralWalkSampling_h
#include <eoInit.h>
#include <eval/moEval.h>
#include <eoEvalFunc.h>
#include <algo/moRandomNeutralWalk.h>
#include <sampling/moSampling.h>
#include <perturb/moSolInit.h>
#include <continuator/moSolutionStat.h>
#include <utils/eoDistance.h>
#include <continuator/moDistanceStat.h>
#include <continuator/moNeighborhoodStat.h>
#include <continuator/moMaxNeighborStat.h>
#include <continuator/moMinNeighborStat.h>
#include <continuator/moAverageFitnessNeighborStat.h>
#include <continuator/moStdFitnessNeighborStat.h>
#include <continuator/moSizeNeighborStat.h>
#include <continuator/moNbInfNeighborStat.h>
#include <continuator/moNbSupNeighborStat.h>
#include <continuator/moNeutralDegreeNeighborStat.h>
/**
* To explore the evolvability of solutions in a neutral networks:
* Perform a random neutral walk based on the neighborhood,
* The measures of evolvability of solutions are collected during the random neutral walk
* The distribution and autocorrelation can be computed from the serie of values
*
* Informations collected:
* - the current solution of the walk
* - the distance from the starting solution
* - the minimal fitness in the neighborhood
* - the average fitness
* - the standard deviation of the fitness
* - the maximal fitness
* - the size of the neighborhood
* - the number of neighbors with lower fitness
* - the number of neighbors with equal fitness (neutral degree)
* - the number of neighbors with higher fitness
*/
template <class Neighbor>
class moNeutralWalkSampling : public moSampling<Neighbor>
{
public:
typedef typename Neighbor::EOT EOT ;
using moSampling<Neighbor>::localSearch;
/**
* Constructor
* @param _initSol the first solution of the walk
* @param _neighborhood neighborhood giving neighbor in random order
* @param _fullEval Fitness function, full evaluation function
* @param _eval neighbor evaluation, incremental evaluation function
* @param _distance component to measure the distance from the initial solution
* @param _nbStep Number of steps of the random walk
*/
moNeutralWalkSampling(EOT & _initSol,
moNeighborhood<Neighbor> & _neighborhood,
eoEvalFunc<EOT>& _fullEval,
moEval<Neighbor>& _eval,
eoDistance<EOT> & _distance,
unsigned int _nbStep) :
moSampling<Neighbor>(init, * new moRandomNeutralWalk<Neighbor>(_neighborhood, _fullEval, _eval, _nbStep), solutionStat),
init(_initSol),
distStat(_distance, _initSol),
neighborhoodStat(_neighborhood, _eval),
minStat(neighborhoodStat),
averageStat(neighborhoodStat),
stdStat(neighborhoodStat),
maxStat(neighborhoodStat),
nbSupStat(neighborhoodStat),
nbInfStat(neighborhoodStat),
sizeStat(neighborhoodStat),
ndStat(neighborhoodStat)
{
add(neighborhoodStat, false);
add(distStat);
add(minStat);
add(averageStat);
add(stdStat);
add(maxStat);
add(sizeStat);
add(nbInfStat);
add(ndStat);
add(nbSupStat);
}
/**
* default destructor
*/
~moNeutralWalkSampling() {
// delete the pointer on the local search which has been constructed in the constructor
delete localSearch;
}
protected:
moSolInit<EOT> init;
moSolutionStat<EOT> solutionStat;
moDistanceStat<EOT> distStat;
moNeighborhoodStat< Neighbor > neighborhoodStat;
moMinNeighborStat< Neighbor > minStat;
moAverageFitnessNeighborStat< Neighbor > averageStat;
moStdFitnessNeighborStat< Neighbor > stdStat;
moMaxNeighborStat< Neighbor > maxStat;
moNbSupNeighborStat< Neighbor > nbSupStat;
moNbInfNeighborStat< Neighbor > nbInfStat;
moSizeNeighborStat< Neighbor > sizeStat;
moNeutralDegreeNeighborStat< Neighbor > ndStat;
};
#endif

111
tags/ParadisEO-GPU-1.1/paradiseo-mo/src/sampling/moRndBestFitnessCloudSampling.h
View file

@ -1,111 +0,0 @@
/*
<moRndBestFitnessCloudSampling.h>
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 moRndBestFitnessCloudSampling_h
#define moRndBestFitnessCloudSampling_h
#include <eoInit.h>
#include <neighborhood/moNeighborhood.h>
#include <eval/moEval.h>
#include <eoEvalFunc.h>
#include <algo/moRandomSearch.h>
#include <continuator/moNeighborBestStat.h>
#include <sampling/moFitnessCloudSampling.h>
/**
* To compute an estimation of the fitness cloud,
* i.e. the scatter plot of solution fitness versus neighbor fitness:
*
* Sample the fitness of random solution in the search space
* and the best fitness of k random neighbor
*
* The values are collected during the random search
*
*/
template <class Neighbor>
class moRndBestFitnessCloudSampling : public moFitnessCloudSampling<Neighbor>
{
public:
typedef typename Neighbor::EOT EOT ;
using moSampling<Neighbor>::localSearch;
using moSampling<Neighbor>::checkpoint;
using moSampling<Neighbor>::monitorVec;
using moSampling<Neighbor>::continuator;
using moFitnessCloudSampling<Neighbor>::fitnessStat;
/**
* Constructor
* @param _init initialisation method of the solution
* @param _neighborhood neighborhood to get one random neighbor (supposed to be random neighborhood)
* @param _fullEval Fitness function, full evaluation function
* @param _eval neighbor evaluation, incremental evaluation function
* @param _nbSol Number of solutions in the sample
*/
moRndBestFitnessCloudSampling(eoInit<EOT> & _init,
moNeighborhood<Neighbor> & _neighborhood,
eoEvalFunc<EOT>& _fullEval,
moEval<Neighbor>& _eval,
unsigned int _nbSol) :
moFitnessCloudSampling<Neighbor>(_init, _neighborhood, _fullEval, _eval, _nbSol),
neighborBestStat(_neighborhood, _eval)
{
// delete the dummy local search
delete localSearch;
// random sampling
localSearch = new moRandomSearch<Neighbor>(_init, _fullEval, _nbSol);
// delete the checkpoint with the wrong continuator
delete checkpoint;
// set the continuator
continuator = localSearch->getContinuator();
// re-construction of the checkpoint
checkpoint = new moCheckpoint<Neighbor>(*continuator);
checkpoint->add(fitnessStat);
checkpoint->add(*monitorVec[0]);
// one random neighbor
add(neighborBestStat);
}
protected:
moNeighborBestStat< Neighbor > neighborBestStat;
};
#endif

111
tags/ParadisEO-GPU-1.1/paradiseo-mo/src/sampling/moRndRndFitnessCloudSampling.h
View file

@ -1,111 +0,0 @@
/*
<moRndRndFitnessCloudSampling.h>
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 moRndRndFitnessCloudSampling_h
#define moRndRndFitnessCloudSampling_h
#include <eoInit.h>
#include <neighborhood/moNeighborhood.h>
#include <eval/moEval.h>
#include <eoEvalFunc.h>
#include <algo/moRandomSearch.h>
#include <continuator/moNeighborFitnessStat.h>
#include <sampling/moFitnessCloudSampling.h>
/**
* To compute an estimation of the fitness cloud,
* i.e. the scatter plot of solution fitness versus neighbor fitness:
*
* Sample the fitness of random solution in the search space
* and the fitness of one random neighbor
*
* The values are collected during the random search
*
*/
template <class Neighbor>
class moRndRndFitnessCloudSampling : public moFitnessCloudSampling<Neighbor>
{
public:
typedef typename Neighbor::EOT EOT ;
using moSampling<Neighbor>::localSearch;
using moSampling<Neighbor>::checkpoint;
using moSampling<Neighbor>::monitorVec;
using moSampling<Neighbor>::continuator;
using moFitnessCloudSampling<Neighbor>::fitnessStat;
/**
* Constructor
* @param _init initialisation method of the solution
* @param _neighborhood neighborhood to get one random neighbor (supposed to be random neighborhood)
* @param _fullEval Fitness function, full evaluation function
* @param _eval neighbor evaluation, incremental evaluation function
* @param _nbSol Number of solutions in the sample
*/
moRndRndFitnessCloudSampling(eoInit<EOT> & _init,
moNeighborhood<Neighbor> & _neighborhood,
eoEvalFunc<EOT>& _fullEval,
moEval<Neighbor>& _eval,
unsigned int _nbSol) :
moFitnessCloudSampling<Neighbor>(_init, _neighborhood, _fullEval, _eval, _nbSol),
neighborFitnessStat(_neighborhood, _eval)
{
// delete the dummy local search
delete localSearch;
// random sampling
localSearch = new moRandomSearch<Neighbor>(_init, _fullEval, _nbSol);
// delete the checkpoint with the wrong continuator
delete checkpoint;
// set the continuator
continuator = localSearch->getContinuator();
// re-construction of the checkpoint
checkpoint = new moCheckpoint<Neighbor>(*continuator);
checkpoint->add(fitnessStat);
checkpoint->add(*monitorVec[0]);
// one random neighbor
add(neighborFitnessStat);
}
protected:
moNeighborFitnessStat< Neighbor > neighborFitnessStat;
};
#endif

239
tags/ParadisEO-GPU-1.1/paradiseo-mo/src/sampling/moSampling.h
View file

@ -1,239 +0,0 @@
/*
<moSampling.h>
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 moSampling_h
#define moSampling_h
#include <vector>
#include <fstream>
#include <iostream>
#include <sstream>
#include <cstdlib>
#include <eoFunctor.h>
#include <utils/eoMonitor.h>
#include <continuator/moStat.h>
#include <continuator/moCheckpoint.h>
#include <continuator/moVectorMonitor.h>
#include <algo/moLocalSearch.h>
#include <eoInit.h>
/**
* To sample the search space:
* A local search is used to sample the search space
* Some statistics are computed at each step of the local search
*
* Can be used to study the fitness landscape
*/
template <class Neighbor>
class moSampling : public eoF<void>
{
public:
typedef typename Neighbor::EOT EOT ;
/**
* Constructor
* @param _init initialisation method of the solution
* @param _localSearch local search to sample the search space
* @param _stat statistic to compute during the search
* @param _monitoring the statistic is saved into the monitor if true
*/
template <class ValueType>
moSampling(eoInit<EOT> & _init, moLocalSearch<Neighbor> & _localSearch, moStat<EOT,ValueType> & _stat, bool _monitoring = true) : init(_init), localSearch(&_localSearch), continuator(_localSearch.getContinuator())
{
checkpoint = new moCheckpoint<Neighbor>(*continuator);
add(_stat, _monitoring);
// precision of the output by default
precisionOutput = std::cout.precision();
}
/**
* default destructor
*/
~moSampling() {
// delete all monitors
for (unsigned i = 0; i < monitorVec.size(); i++)
delete monitorVec[i];
// delete the checkpoint
delete checkpoint ;
}
/**
* Add a statistic
* @param _stat another statistic to compute during the search
* @param _monitoring the statistic is saved into the monitor if true
*/
template< class ValueType >
void add(moStat<EOT, ValueType> & _stat, bool _monitoring = true) {
checkpoint->add(_stat);
if (_monitoring) {
moVectorMonitor<EOT> * monitor = new moVectorMonitor<EOT>(_stat);
monitorVec.push_back(monitor);
checkpoint->add(*monitor);
}
}
/**
* To sample the search and get the statistics which are stored in the moVectorMonitor vector
*/
void operator()(void) {
// clear all statistic vectors
for (unsigned i = 0; i < monitorVec.size(); i++)
monitorVec[i]->clear();
// change the checkpoint to compute the statistics
localSearch->setContinuator(*checkpoint);
// the initial solution
EOT solution;
// initialisation of the solution
init(solution);
// compute the sampling
(*localSearch)(solution);
// set back to initial continuator
localSearch->setContinuator(*continuator);
}
/**
* to set the precision of the output file
* @param _precision precision of the output (number of digit)
*/
void precision(unsigned int _precision) {
precisionOutput = _precision;
}
/**
* to export the vectors of values into one file
* @param _filename file name
* @param _delim delimiter between statistics
* @param _openFile to specify if it writes at the following of the file
*/
void fileExport(std::string _filename, std::string _delim = " ", bool _openFile=false) {
// create file
std::ofstream os;
if(! _openFile)
os.open(_filename.c_str());
else
os.open(_filename.c_str(),std::ios::app);
if (!os) {
std::string str = "moSampling: Could not open " + _filename;
throw std::runtime_error(str);
}
// set the precision of the output
os.precision(precisionOutput);
for (unsigned int j = 0; j < monitorVec.size(); j++)
monitorVec[j]->precision(precisionOutput);
// all vector have the same size
unsigned vecSize = monitorVec[0]->size();
for (unsigned int i = 0; i < vecSize; i++) {
os << monitorVec[0]->getValue(i);
for (unsigned int j = 1; j < monitorVec.size(); j++) {
os << _delim.c_str() << monitorVec[j]->getValue(i);
}
os << std::endl ;
}
}
/**
* to export one vector of values into a file
* @param _col number of vector to print into file
* @param _filename file name
* @param _openFile to specify if it writes at the following of the file
*/
void fileExport(unsigned int _col, std::string _filename, bool _openFile=false) {
if (_col >= monitorVec.size()) {
std::string str = "moSampling: Could not export into file the vector. The index does not exists (too large)";
throw std::runtime_error(str);
}
monitorVec[_col]->precision(precisionOutput);
monitorVec[_col]->fileExport(_filename, _openFile);
}
/**
* to get one vector of values
* @param _numStat number of statistics to get (in the order of creation)
* @return the vector of value (all values are converted in double)
*/
const std::vector<double> & getValues(unsigned int _numStat) {
return monitorVec[_numStat]->getValues();
}
/**
* to get one vector of solutions values
* @param _numStat number of statistics to get (in the order of creation)
* @return the vector of value (all values are converted in double)
*/
const std::vector<EOT> & getSolutions(unsigned int _numStat) {
return monitorVec[_numStat]->getSolutions();
}
/**
* @return name of the class
*/
virtual std::string className(void) const {
return "moSampling";
}
protected:
eoInit<EOT> & init;
moLocalSearch<Neighbor> * localSearch;
moContinuator<Neighbor> * continuator;
moCheckpoint<Neighbor> * checkpoint;
std::vector< moVectorMonitor<EOT> *> monitorVec;
// precision of the output
unsigned int precisionOutput;
};
#endif

Some files were not shown because too many files have changed in this diff Show more