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

Merge branch 'master' of ssh://localhost:8479/gitroot/eodev/eodev

Browse source
This commit is contained in:
nojhan 2012-07-13 15:35:02 +02:00
commit 09d08bf043
55 changed files with 1660 additions and 1064 deletions
Download patch file Download diff file Expand all files Collapse all files

52
edo/CMakeLists.txt
View file

@ -16,8 +16,8 @@ CMAKE_MINIMUM_REQUIRED(VERSION 2.6)
PROJECT(EDO) PROJECT(EDO)
SET(PROJECT_VERSION_MAJOR 1) SET(PROJECT_VERSION_MAJOR 0)
SET(PROJECT_VERSION_MINOR 0) SET(PROJECT_VERSION_MINOR 1)
SET(PROJECT_VERSION_PATCH 0) SET(PROJECT_VERSION_PATCH 0)
SET(PROJECT_VERSION "${PROJECT_VERSION_MAJOR}.${PROJECT_VERSION_MINOR}.${PROJECT_VERSION_PATCH}") SET(PROJECT_VERSION "${PROJECT_VERSION_MAJOR}.${PROJECT_VERSION_MINOR}.${PROJECT_VERSION_PATCH}")
@ -29,25 +29,57 @@ SET(PROJECT_VERSION "${PROJECT_VERSION_MAJOR}.${PROJECT_VERSION_MINOR}.${PROJECT
###################################################################################### ######################################################################################
# include useful features for cmake # include useful features for cmake
SET(CMAKE_MODULE_PATH ${CMAKE_SOURCE_DIR}/cmake/modules) SET(CMAKE_MODULE_PATH ${PROJECT_SOURCE_DIR} ${CMAKE_SOURCE_DIR}/cmake/modules)
INCLUDE(FindDoxygen) INCLUDE(FindDoxygen)
INCLUDE(FindPkgConfig) INCLUDE(FindPkgConfig)
FIND_PACKAGE(Boost 1.33.0) IF( WITH_BOOST AND WITH_EIGEN )
MESSAGE( "ERROR: You have to choose between Boost:ublas and Eigen, you cannot compile with both libraries" )
SET(IS_FATAL 1)
ELSEIF( NOT WITH_BOOST AND NOT WITH_EIGEN )
#MESSAGE( "WARNING: Boost:ublas and Eigen are both deactivated, some features may lack." )
# FIXME ideally, we would have a minimal implementation with STL vectors…
MESSAGE( "FIXME: Boost:ublas and Eigen are both deactivated, too much features will lack, you should choose one." )
SET(IS_FATAL 1)
ENDIF()
IF(WITH_BOOST)
FIND_PACKAGE(Boost 1.33.0)
IF( Boost_FOUND )
INCLUDE_DIRECTORIES( ${Boost_INCLUDE_DIRS} )
ADD_DEFINITIONS( -DWITH_BOOST )
ELSE()
MESSAGE( "ERROR: You asked for Boost:ublas but it has nost been found." )
SET(IS_FATAL 1)
ENDIF()
ELSEIF( WITH_EIGEN )
# FIXME FindEigen3.cmake does not work
#find_package(Eigen3)
#include_directories(EIGEN3_INCLUDE_DIR)
SET( EIGEN3_FOUND 1)
SET( EIGEN3_INCLUDE_DIR "/usr/include/eigen3/" )
IF( EIGEN3_FOUND )
INCLUDE_DIRECTORIES( ${EIGEN3_INCLUDE_DIR} )
ADD_DEFINITIONS( -DWITH_EIGEN )
ELSE()
MESSAGE( "ERROR: You asked for Eigen but it has nost been found." )
SET(IS_FATAL 1)
ENDIF()
ENDIF()
FIND_PACKAGE(EO) FIND_PACKAGE(EO)
INCLUDE_DIRECTORIES( INCLUDE_DIRECTORIES(
${EO_INCLUDE_DIRS} ${EO_INCLUDE_DIRS}
${MO_INCLUDE_DIRS} ${MO_INCLUDE_DIRS}
${Boost_INCLUDE_DIRS} )
# /Dev/ometah-0.3/common
)
LINK_DIRECTORIES( LINK_DIRECTORIES(
${EO_LIBRARY_DIRS} ${EO_LIBRARY_DIRS}
) )
###################################################################################### ######################################################################################
@ -58,7 +90,7 @@ LINK_DIRECTORIES(
INCLUDE_DIRECTORIES( INCLUDE_DIRECTORIES(
${CMAKE_CURRENT_SOURCE_DIR}/src ${CMAKE_CURRENT_SOURCE_DIR}/src
) )
###################################################################################### ######################################################################################
@ -92,7 +124,7 @@ SET(SAMPLE_SRCS)
###################################################################################### ######################################################################################
ADD_SUBDIRECTORY(src) ADD_SUBDIRECTORY(src)
#ADD_SUBDIRECTORY(application) ADD_SUBDIRECTORY(application)
ADD_SUBDIRECTORY(test) ADD_SUBDIRECTORY(test)
ADD_SUBDIRECTORY(doc) ADD_SUBDIRECTORY(doc)

8
edo/NEWS Normal file
View file

@ -0,0 +1,8 @@
* current release
- alternative implementation of the multi-normal operators using the Eigen3 library
* release 0.0 (2011-09-15)
- basic design for estimation of distribution algorithms and, more generally for randomized search heuristics
- continuous EDA example
- EDA using multi-normal distribution, implementation using the boost::ublas library

6
edo/README
View file

@ -33,11 +33,11 @@ In the edo/build/ directory:
(Unix) > ctest (Unix) > ctest
Windows users, please refer to this tutorial: http://paradiseo.gforge.inria.fr/index.php?n=Paradiseo.VisualCTutorial Windows users, please refer to this tutorial: http://paradiseo.gforge.inria.fr/index.php?n=Paradiseo.VisualCTutorial
In the directory "application", there are several directory such as eda_sa which instantiate EDA-SA solver. In the directory "application", there are several directory such as eda which instantiate EDA solver.
(Unix) After compilation you can run the binary "build/eda_sa" and see results. Parameters can be modified from command line. (Unix) After compilation you can run the binary "build/eda" and see results. Parameters can be modified from command line.
(Windows) Add argument "eda_sa.param" and execute the corresponding algorithms. (Windows) Add argument "eda.param" and execute the corresponding algorithms.
Windows users, please refer to this tutorial: http://paradiseo.gforge.inria.fr/index.php?n=Paradiseo.VisualCTutorial Windows users, please refer to this tutorial: http://paradiseo.gforge.inria.fr/index.php?n=Paradiseo.VisualCTutorial

4
edo/application/CMakeLists.txt
View file

@ -7,8 +7,8 @@ INCLUDE_DIRECTORIES(
) )
ADD_SUBDIRECTORY(common) ADD_SUBDIRECTORY(common)
ADD_SUBDIRECTORY(eda_sa) #ADD_SUBDIRECTORY(eda_sa)
ADD_SUBDIRECTORY(eda) ADD_SUBDIRECTORY(eda)
#ADD_SUBDIRECTORY(sa) ADD_SUBDIRECTORY(cmaes)
###################################################################################### ######################################################################################

33
edo/application/cmaes/CMakeLists.txt Normal file
View file

@ -0,0 +1,33 @@
PROJECT(cmaes)
#find_package(Eigen3 REQUIRED)
#include_directories(EIGEN3_INCLUDE_DIR)
INCLUDE_DIRECTORIES( ${EIGEN3_INCLUDE_DIR} )
MESSAGE( "MESSAGE:" ${EIGEN3_INCLUDE_DIR} )
#FIND_PACKAGE(Boost 1.33.0)
INCLUDE_DIRECTORIES(${Boost_INCLUDE_DIRS})
LINK_DIRECTORIES(${Boost_LIBRARY_DIRS})
INCLUDE_DIRECTORIES(${CMAKE_CURRENT_SOURCE_DIR})
SET(RESOURCES
${PROJECT_NAME}.param
)
FOREACH(file ${RESOURCES})
EXECUTE_PROCESS(
COMMAND ${CMAKE_COMMAND} -E copy_if_different
${CMAKE_CURRENT_SOURCE_DIR}/${file}
${EDO_BINARY_DIR}/${file}
)
ENDFOREACH(file)
#FILE(GLOB SOURCES *.cpp)
SET(EXECUTABLE_OUTPUT_PATH ${EDO_BINARY_DIR})
ADD_EXECUTABLE(${PROJECT_NAME} main.cpp)
TARGET_LINK_LIBRARIES(${PROJECT_NAME} edo edoutils ${EO_LIBRARIES} ${Boost_LIBRARIES})

181
edo/application/cmaes/main.cpp Normal file
View file

@ -0,0 +1,181 @@
/*
The Evolving Distribution Objects framework (EDO) is a template-based,
ANSI-C++ evolutionary computation library which helps you to write your
own estimation of distribution algorithms.
This library is free software; you can redistribute it and/or
modify it under the terms of the GNU Lesser General Public
License as published by the Free Software Foundation; either
version 2.1 of the License, or (at your option) any later version.
This library is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
Lesser General Public License for more details.
You should have received a copy of the GNU Lesser General Public
License along with this library; if not, write to the Free Software
Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
Copyright (C) 2010 Thales group
*/
/*
Authors:
Johann Dréo <johann.dreo@thalesgroup.com>
Caner Candan <caner.candan@thalesgroup.com>
*/
#include <eo>
#include <mo>
#include <eoEvalFuncCounterBounder.h>
#include <do/make_pop.h>
#include <do/make_run.h>
#include <do/make_continue.h>
#include <do/make_checkpoint.h>
#include <edo>
#include "Rosenbrock.h"
#include "Sphere.h"
typedef eoReal<eoMinimizingFitness> EOT;
typedef edoNormalMulti< EOT > Distrib;
int main(int ac, char** av)
{
eoParser parser(ac, av);
// Letters used by the following declarations:
// a d i p t
std::string section("Algorithm parameters");
eoState state;
// Instantiate all needed parameters for EDA algorithm
double selection_rate = parser.createParam((double)0.5, "selection_rate", "Selection Rate", 'R', section).value(); // R
eoSelect< EOT >* selector = new eoDetSelect< EOT >( selection_rate );
state.storeFunctor(selector);
edoEstimator< Distrib >* estimator = new edoEstimatorNormalMulti< EOT >();
state.storeFunctor(estimator);
eoEvalFunc< EOT >* plainEval = new Rosenbrock< EOT >();
state.storeFunctor(plainEval);
unsigned long max_eval = parser.getORcreateParam((unsigned long)0, "maxEval", "Maximum number of evaluations (0 = none)", 'E', "Stopping criterion").value(); // E
eoEvalFuncCounterBounder< EOT > eval(*plainEval, max_eval);
eoRndGenerator< double >* gen = new eoUniformGenerator< double >(-5, 5);
state.storeFunctor(gen);
unsigned int dimension_size = parser.createParam((unsigned int)10, "dimension-size", "Dimension size", 'd', section).value(); // d
eoInitFixedLength< EOT >* init = new eoInitFixedLength< EOT >( dimension_size, *gen );
state.storeFunctor(init);
// (1) Population init and sampler
// Generation of population from do_make_pop (creates parameters, manages persistance and so on...)
// ... and creates the parameters: L P r S
// this first sampler creates a uniform distribution independently from our distribution (it does not use edoUniform).
eoPop< EOT >& pop = do_make_pop(parser, state, *init);
// (2) First evaluation before starting the research algorithm
apply(eval, pop);
// Prepare bounder class to set bounds of sampling.
// This is used by edoSampler.
edoBounder< EOT >* bounder =
new edoBounderRng< EOT >( EOT(pop[0].size(), -5), EOT(pop[0].size(), 5), *gen); // FIXME do not use hard-coded bounds
state.storeFunctor(bounder);
// Prepare sampler class with a specific distribution
edoSampler< Distrib >* sampler = new edoSamplerNormalMulti< EOT >( *bounder );
state.storeFunctor(sampler);
// stopping criteria
// ... and creates the parameter letters: C E g G s T
eoContinue< EOT >& eo_continue = do_make_continue(parser, state, eval);
// population output
eoCheckPoint< EOT >& pop_continue = do_make_checkpoint(parser, state, eval, eo_continue);
// distribution output
edoDummyContinue< Distrib >* dummy_continue = new edoDummyContinue< Distrib >();
state.storeFunctor(dummy_continue);
edoCheckPoint< Distrib >* distribution_continue = new edoCheckPoint< Distrib >( *dummy_continue );
state.storeFunctor(distribution_continue);
// eoEPRemplacement causes the using of the current and previous
// sample for sampling.
eoReplacement< EOT >* replacor = new eoEPReplacement< EOT >(pop.size());
state.storeFunctor(replacor);
// Some stuff to display helper when we are using -h option
if (parser.userNeedsHelp())
{
parser.printHelp(std::cout);
exit(1);
}
// Help + Verbose routines
make_verbose(parser);
make_help(parser);
// population output (after helper)
//
// FIXME: theses objects are instanciated there in order to avoid a folder
// removing as edoFileSnapshot does within ctor.
edoPopStat< EOT >* popStat = new edoPopStat<EOT>;
state.storeFunctor(popStat);
pop_continue.add(*popStat);
edoFileSnapshot* fileSnapshot = new edoFileSnapshot("EDA_ResPop");
state.storeFunctor(fileSnapshot);
fileSnapshot->add(*popStat);
pop_continue.add(*fileSnapshot);
// distribution output (after helper)
edoDistribStat< Distrib >* distrib_stat = new edoStatNormalMulti< EOT >();
state.storeFunctor(distrib_stat);
distribution_continue->add( *distrib_stat );
// eoMonitor* stdout_monitor = new eoStdoutMonitor();
// state.storeFunctor(stdout_monitor);
// stdout_monitor->add(*distrib_stat);
// distribution_continue->add( *stdout_monitor );
eoFileMonitor* file_monitor = new eoFileMonitor("eda_distribution_bounds.txt");
state.storeFunctor(file_monitor);
file_monitor->add(*distrib_stat);
distribution_continue->add( *file_monitor );
eoPopLoopEval<EOT> popEval( eval );
// EDA algorithm configuration
edoAlgo< Distrib >* algo = new edoEDA< Distrib >
(popEval, *selector, *estimator, *sampler, *replacor,
pop_continue, *distribution_continue );
// Beginning of the algorithm call
try {
do_run(*algo, pop);
} catch (eoEvalFuncCounterBounderException& e) {
eo::log << eo::warnings << "warning: " << e.what() << std::endl;
} catch (std::exception& e) {
eo::log << eo::errors << "error: " << e.what() << std::endl;
exit(EXIT_FAILURE);
}
return 0;
}

19
edo/application/eda/main.cpp
View file

@ -26,7 +26,7 @@ Authors:
*/ */
#include <eo> #include <eo>
#include <mo> // #include <mo>
#include <eoEvalFuncCounterBounder.h> #include <eoEvalFuncCounterBounder.h>
@ -92,7 +92,7 @@ int main(int ac, char** av)
// Prepare bounder class to set bounds of sampling. // Prepare bounder class to set bounds of sampling.
// This is used by edoSampler. // This is used by edoSampler.
edoBounder< EOT >* bounder = edoBounder< EOT >* bounder =
new edoBounderRng< EOT >( EOT(pop[0].size(), -5), EOT(pop[0].size(), 5), *gen); // FIXME do not use hard-coded bounds new edoBounderRng< EOT >( EOT(dimension_size, -5), EOT(dimension_size, 5), *gen); // FIXME do not use hard-coded bounds
state.storeFunctor(bounder); state.storeFunctor(bounder);
// Prepare sampler class with a specific distribution // Prepare sampler class with a specific distribution
@ -117,7 +117,11 @@ int main(int ac, char** av)
// sample for sampling. // sample for sampling.
eoReplacement< EOT >* replacor = new eoEPReplacement< EOT >(pop.size()); eoReplacement< EOT >* replacor = new eoEPReplacement< EOT >(pop.size());
state.storeFunctor(replacor); state.storeFunctor(replacor);
// Help + Verbose routines
make_verbose(parser);
make_help(parser);
// Some stuff to display helper when we are using -h option // Some stuff to display helper when we are using -h option
if (parser.userNeedsHelp()) if (parser.userNeedsHelp())
{ {
@ -125,10 +129,6 @@ int main(int ac, char** av)
exit(1); exit(1);
} }
// Help + Verbose routines
make_verbose(parser);
make_help(parser);
// population output (after helper) // population output (after helper)
// //
// FIXME: theses objects are instanciated there in order to avoid a folder // FIXME: theses objects are instanciated there in order to avoid a folder
@ -162,9 +162,8 @@ int main(int ac, char** av)
// EDA algorithm configuration // EDA algorithm configuration
edoAlgo< Distrib >* algo = new edoEDA< Distrib > edoAlgo< Distrib >* algo = new edoEDA< Distrib >
(*selector, *estimator, *sampler, (popEval, *selector, *estimator, *sampler, *replacor,
pop_continue, *distribution_continue, pop_continue, *distribution_continue );
popEval, *replacor);
// Beginning of the algorithm call // Beginning of the algorithm call
try { try {

2
edo/build_gcc_linux_debug
View file

@ -2,6 +2,6 @@
mkdir -p debug mkdir -p debug
cd debug cd debug
cmake -DCMAKE_BUILD_TYPE=Debug .. cmake -DCMAKE_BUILD_TYPE=Debug -DWITH_BOOST=1 ..
make make
cd .. cd ..

7
edo/build_gcc_linux_eigen_debug Executable file
View file

@ -0,0 +1,7 @@
#!/usr/bin/env sh
mkdir -p debug
cd debug
cmake -DCMAKE_BUILD_TYPE=Debug -DWITH_EIGEN=1 ..
make
cd ..

222
edo/src/edoEstimatorNormalMulti.h
View file

@ -29,11 +29,13 @@ Authors:
#ifndef _edoEstimatorNormalMulti_h #ifndef _edoEstimatorNormalMulti_h
#define _edoEstimatorNormalMulti_h #define _edoEstimatorNormalMulti_h
#include "edoEstimator.h" #include "edoEstimator.h"
#include "edoNormalMulti.h" #include "edoNormalMulti.h"
//! edoEstimatorNormalMulti< EOT > #ifdef WITH_BOOST
//! edoEstimatorNormalMulti< EOT >
template < typename EOT > template < typename EOT >
class edoEstimatorNormalMulti : public edoEstimator< edoNormalMulti< EOT > > class edoEstimatorNormalMulti : public edoEstimator< edoNormalMulti< EOT > >
{ {
@ -41,95 +43,95 @@ public:
class CovMatrix class CovMatrix
{ {
public: public:
typedef typename EOT::AtomType AtomType; typedef typename EOT::AtomType AtomType;
CovMatrix( const eoPop< EOT >& pop ) CovMatrix( const eoPop< EOT >& pop )
{ {
//------------------------------------------------------------- //-------------------------------------------------------------
// Some checks before starting to estimate covar // Some checks before starting to estimate covar
//------------------------------------------------------------- //-------------------------------------------------------------
unsigned int p_size = pop.size(); // population size unsigned int p_size = pop.size(); // population size
assert(p_size > 0); assert(p_size > 0);
unsigned int s_size = pop[0].size(); // solution size unsigned int s_size = pop[0].size(); // solution size
assert(s_size > 0); assert(s_size > 0);
//------------------------------------------------------------- //-------------------------------------------------------------
//------------------------------------------------------------- //-------------------------------------------------------------
// Copy the population to an ublas matrix // Copy the population to an ublas matrix
//------------------------------------------------------------- //-------------------------------------------------------------
ublas::matrix< AtomType > sample( p_size, s_size ); ublas::matrix< AtomType > sample( p_size, s_size );
for (unsigned int i = 0; i < p_size; ++i) for (unsigned int i = 0; i < p_size; ++i)
{ {
for (unsigned int j = 0; j < s_size; ++j) for (unsigned int j = 0; j < s_size; ++j)
{ {
sample(i, j) = pop[i][j]; sample(i, j) = pop[i][j];
} }
} }
//------------------------------------------------------------- //-------------------------------------------------------------
_varcovar.resize(s_size); _varcovar.resize(s_size);
//------------------------------------------------------------- //-------------------------------------------------------------
// variance-covariance matrix are symmetric (and semi-definite // variance-covariance matrix are symmetric (and semi-definite
// positive), thus a triangular storage is sufficient // positive), thus a triangular storage is sufficient
// //
// variance-covariance matrix computation : transpose(A) * A // variance-covariance matrix computation : transpose(A) * A
//------------------------------------------------------------- //-------------------------------------------------------------
ublas::symmetric_matrix< AtomType, ublas::lower > var = ublas::prod( ublas::trans( sample ), sample ); ublas::symmetric_matrix< AtomType, ublas::lower > var = ublas::prod( ublas::trans( sample ), sample );
// Be sure that the symmetric matrix got the good size // Be sure that the symmetric matrix got the good size
assert(var.size1() == s_size); assert(var.size1() == s_size);
assert(var.size2() == s_size); assert(var.size2() == s_size);
assert(var.size1() == _varcovar.size1()); assert(var.size1() == _varcovar.size1());
assert(var.size2() == _varcovar.size2()); assert(var.size2() == _varcovar.size2());
//------------------------------------------------------------- //-------------------------------------------------------------
// TODO: to remove the comment below // TODO: to remove the comment below
// for (unsigned int i = 0; i < s_size; ++i) // for (unsigned int i = 0; i < s_size; ++i)
// { // {
// // triangular LOWER matrix, thus j is not going further than i // // triangular LOWER matrix, thus j is not going further than i
// for (unsigned int j = 0; j <= i; ++j) // for (unsigned int j = 0; j <= i; ++j)
// { // {
// // we want a reducted covariance matrix // // we want a reducted covariance matrix
// _varcovar(i, j) = var(i, j) / p_size; // _varcovar(i, j) = var(i, j) / p_size;
// } // }
// } // }
_varcovar = var / p_size; _varcovar = var / p_size;
_mean.resize(s_size); // FIXME: check if it is really used because of the assignation below _mean.resize(s_size); // FIXME: check if it is really used because of the assignation below
// unit vector // unit vector
ublas::scalar_vector< AtomType > u( p_size, 1 ); ublas::scalar_vector< AtomType > u( p_size, 1 );
// sum over columns // sum over columns
_mean = ublas::prod( ublas::trans( sample ), u ); _mean = ublas::prod( ublas::trans( sample ), u );
// division by n // division by n
_mean /= p_size; _mean /= p_size;
} }
const ublas::symmetric_matrix< AtomType, ublas::lower >& get_varcovar() const {return _varcovar;} const ublas::symmetric_matrix< AtomType, ublas::lower >& get_varcovar() const {return _varcovar;}
const ublas::vector< AtomType >& get_mean() const {return _mean;} const ublas::vector< AtomType >& get_mean() const {return _mean;}
private: private:
ublas::symmetric_matrix< AtomType, ublas::lower > _varcovar; ublas::symmetric_matrix< AtomType, ublas::lower > _varcovar;
ublas::vector< AtomType > _mean; ublas::vector< AtomType > _mean;
}; };
public: public:
@ -137,16 +139,102 @@ public:
edoNormalMulti< EOT > operator()(eoPop<EOT>& pop) edoNormalMulti< EOT > operator()(eoPop<EOT>& pop)
{ {
unsigned int popsize = pop.size(); unsigned int popsize = pop.size();
assert(popsize > 0); assert(popsize > 0);
unsigned int dimsize = pop[0].size(); unsigned int dimsize = pop[0].size();
assert(dimsize > 0); assert(dimsize > 0);
CovMatrix cov( pop ); CovMatrix cov( pop );
return edoNormalMulti< EOT >( cov.get_mean(), cov.get_varcovar() ); return edoNormalMulti< EOT >( cov.get_mean(), cov.get_varcovar() );
} }
}; };
#else
#ifdef WITH_EIGEN
//! edoEstimatorNormalMulti< EOT >
template < typename EOT, typename EOD = edoNormalMulti<EOT> >
class edoEstimatorNormalMulti : public edoEstimator< EOD >
{
public:
class CovMatrix
{
public:
typedef typename EOT::AtomType AtomType;
typedef typename EOD::Vector Vector;
typedef typename EOD::Matrix Matrix;
CovMatrix( const eoPop< EOT >& pop )
{
// Some checks before starting to estimate covar
unsigned int p_size = pop.size(); // population size
assert(p_size > 0);
unsigned int s_size = pop[0].size(); // solution size
assert(s_size > 0);
// Copy the population to an ublas matrix
Matrix sample( p_size, s_size );
for (unsigned int i = 0; i < p_size; ++i) {
for (unsigned int j = 0; j < s_size; ++j) {
sample(i, j) = pop[i][j];
}
}
// variance-covariance matrix are symmetric, thus a triangular storage is sufficient
// variance-covariance matrix computation : transpose(A) * A
Matrix var = sample.transpose() * sample;
// Be sure that the symmetric matrix got the good size
assert(var.innerSize() == s_size);
assert(var.outerSize() == s_size);
_varcovar = var / p_size;
// unit vector
Vector u( p_size);
u = Vector::Constant(p_size, 1);
// sum over columns
_mean = sample.transpose() * u;
// division by n
_mean /= p_size;
}
const Matrix& get_varcovar() const {return _varcovar;}
const Vector& get_mean() const {return _mean;}
private:
Matrix _varcovar;
Vector _mean;
};
public:
typedef typename EOT::AtomType AtomType;
edoNormalMulti< EOT > operator()(eoPop<EOT>& pop)
{
unsigned int p_size = pop.size();
assert(p_size > 0);
unsigned int s_size = pop[0].size();
assert(s_size > 0);
CovMatrix cov( pop );
assert( cov.get_mean().innerSize() == s_size );
assert( cov.get_mean().outerSize() == 1 );
assert( cov.get_varcovar().innerSize() == s_size );
assert( cov.get_varcovar().outerSize() == s_size );
return edoNormalMulti< EOT >( cov.get_mean(), cov.get_varcovar() );
}
};
#endif // WITH_EIGEN
#endif // WITH_BOOST
#endif // !_edoEstimatorNormalMulti_h #endif // !_edoEstimatorNormalMulti_h

69
edo/src/edoNormalMulti.h
View file

@ -21,22 +21,24 @@ Copyright (C) 2010 Thales group
*/ */
/* /*
Authors: Authors:
Johann Dreo <johann.dreo@thalesgroup.com> Johann Dreo <johann.dreo@thalesgroup.com>
Caner Candan <caner.candan@thalesgroup.com> Caner Candan <caner.candan@thalesgroup.com>
*/ */
#ifndef _edoNormalMulti_h #ifndef _edoNormalMulti_h
#define _edoNormalMulti_h #define _edoNormalMulti_h
#include "edoDistrib.h"
#ifdef WITH_BOOST
#include <boost/numeric/ublas/symmetric.hpp> #include <boost/numeric/ublas/symmetric.hpp>
#include <boost/numeric/ublas/lu.hpp> #include <boost/numeric/ublas/lu.hpp>
#include "edoDistrib.h"
namespace ublas = boost::numeric::ublas; namespace ublas = boost::numeric::ublas;
//! edoNormalMulti< EOT > //! edoNormalMulti< EOT >
template < typename EOT > template < typename EOT >
class edoNormalMulti : public edoDistrib< EOT > class edoNormalMulti : public edoDistrib< EOT >
{ {
@ -48,18 +50,18 @@ public:
const ublas::vector< AtomType >& mean, const ublas::vector< AtomType >& mean,
const ublas::symmetric_matrix< AtomType, ublas::lower >& varcovar const ublas::symmetric_matrix< AtomType, ublas::lower >& varcovar
) )
: _mean(mean), _varcovar(varcovar) : _mean(mean), _varcovar(varcovar)
{ {
assert(_mean.size() > 0); assert(_mean.size() > 0);
assert(_mean.size() == _varcovar.size1()); assert(_mean.size() == _varcovar.size1());
assert(_mean.size() == _varcovar.size2()); assert(_mean.size() == _varcovar.size2());
} }
unsigned int size() unsigned int size()
{ {
assert(_mean.size() == _varcovar.size1()); assert(_mean.size() == _varcovar.size1());
assert(_mean.size() == _varcovar.size2()); assert(_mean.size() == _varcovar.size2());
return _mean.size(); return _mean.size();
} }
ublas::vector< AtomType > mean() const {return _mean;} ublas::vector< AtomType > mean() const {return _mean;}
@ -70,4 +72,49 @@ private:
ublas::symmetric_matrix< AtomType, ublas::lower > _varcovar; ublas::symmetric_matrix< AtomType, ublas::lower > _varcovar;
}; };
#else
#ifdef WITH_EIGEN
#include <Eigen/Dense>
template < typename EOT >
class edoNormalMulti : public edoDistrib< EOT >
{
public:
typedef typename EOT::AtomType AtomType;
typedef Eigen::Matrix< AtomType, Eigen::Dynamic, 1> Vector;
typedef Eigen::Matrix< AtomType, Eigen::Dynamic, Eigen::Dynamic> Matrix;
edoNormalMulti(
const Vector & mean,
const Matrix & varcovar
)
: _mean(mean), _varcovar(varcovar)
{
assert(_mean.innerSize() > 0);
assert(_mean.innerSize() == _varcovar.innerSize());
assert(_mean.innerSize() == _varcovar.outerSize());
}
unsigned int size()
{
assert(_mean.innerSize() == _varcovar.innerSize());
assert(_mean.innerSize() == _varcovar.outerSize());
return _mean.innerSize();
}
Vector mean() const {return _mean;}
Matrix varcovar() const {return _varcovar;}
private:
Vector _mean;
Matrix _varcovar;
};
#endif // WITH_EIGEN
#endif // WITH_BOOST
#endif // !_edoNormalMulti_h #endif // !_edoNormalMulti_h

33
edo/src/edoNormalMultiCenter.h
View file

@ -31,6 +31,8 @@ Authors:
#include "edoModifierMass.h" #include "edoModifierMass.h"
#include "edoNormalMulti.h" #include "edoNormalMulti.h"
#ifdef WITH_BOOST
//! edoNormalMultiCenter< EOT > //! edoNormalMultiCenter< EOT >
template < typename EOT > template < typename EOT >
@ -41,10 +43,35 @@ public:
void operator() ( edoNormalMulti< EOT >& distrib, EOT& mass ) void operator() ( edoNormalMulti< EOT >& distrib, EOT& mass )
{ {
ublas::vector< AtomType > mean( distrib.size() ); ublas::vector< AtomType > mean( distrib.size() );
std::copy( mass.begin(), mass.end(), mean.begin() ); std::copy( mass.begin(), mass.end(), mean.begin() );
distrib.mean() = mean; distrib.mean() = mean;
} }
}; };
#else
#ifdef WITH_EIGEN
template < typename EOT, typename EOD = edoNormalMulti< EOT > >
class edoNormalMultiCenter : public edoModifierMass<EOD>
{
public:
typedef typename EOT::AtomType AtomType;
typedef typename EOD::Vector Vector;
void operator() ( edoNormalMulti< EOT >& distrib, EOT& mass )
{
assert( distrib.size() == mass.innerSize() );
Vector mean( distrib.size() );
for( unsigned int i=0; i < distrib.size(); i++ ) {
mean(i) = mass[i];
}
distrib.mean() = mean;
}
};
#endif // WITH_EIGEN
#endif // WITH_BOOST
#endif // !_edoNormalMultiCenter_h #endif // !_edoNormalMultiCenter_h

92
edo/src/edoSamplerNormalMulti.h
View file

@ -32,9 +32,6 @@ Authors:
#include <limits> #include <limits>
#include <edoSampler.h> #include <edoSampler.h>
#include <utils/edoCholesky.h>
#include <boost/numeric/ublas/lu.hpp>
#include <boost/numeric/ublas/symmetric.hpp>
/** Sample points in a multi-normal law defined by a mean vector and a covariance matrix. /** Sample points in a multi-normal law defined by a mean vector and a covariance matrix.
* *
@ -43,6 +40,13 @@ Authors:
* - compute the Cholesky decomposition L of V (i.e. such as V=LL*) * - compute the Cholesky decomposition L of V (i.e. such as V=LL*)
* - return X = M + LT * - return X = M + LT
*/ */
#ifdef WITH_BOOST
#include <utils/edoCholesky.h>
#include <boost/numeric/ublas/lu.hpp>
#include <boost/numeric/ublas/symmetric.hpp>
template< class EOT, typename EOD = edoNormalMulti< EOT > > template< class EOT, typename EOD = edoNormalMulti< EOT > >
class edoSamplerNormalMulti : public edoSampler< EOD > class edoSamplerNormalMulti : public edoSampler< EOD >
{ {
@ -84,4 +88,86 @@ protected:
cholesky::CholeskyLLT<AtomType> _cholesky; cholesky::CholeskyLLT<AtomType> _cholesky;
}; };
#else
#ifdef WITH_EIGEN
template< class EOT, typename EOD = edoNormalMulti< EOT > >
class edoSamplerNormalMulti : public edoSampler< EOD >
{
public:
typedef typename EOT::AtomType AtomType;
typedef typename EOD::Vector Vector;
typedef typename EOD::Matrix Matrix;
edoSamplerNormalMulti( edoRepairer<EOT> & repairer )
: edoSampler< EOD >( repairer)
{}
EOT sample( EOD& distrib )
{
unsigned int size = distrib.size();
assert(size > 0);
// LsD = cholesky decomposition of varcovar
// Computes L and D such as V = L D L^T
Eigen::LDLT<Matrix> cholesky( distrib.varcovar() );
Matrix L = cholesky.matrixL();
assert(L.innerSize() == size);
assert(L.outerSize() == size);
Matrix D = cholesky.vectorD().asDiagonal();
assert(D.innerSize() == size);
assert(D.outerSize() == size);
// now compute the final symetric matrix: LsD = L D^1/2
// remember that V = ( L D^1/2) ( L D^1/2)^T
// fortunately, the square root of a diagonal matrix is the square
// root of all its elements
Matrix sqrtD = D.cwiseSqrt();
assert(sqrtD.innerSize() == size);
assert(sqrtD.outerSize() == size);
Matrix LsD = L * sqrtD;
assert(LsD.innerSize() == size);
assert(LsD.outerSize() == size);
// T = vector of size elements drawn in N(0,1)
Vector T( size );
for ( unsigned int i = 0; i < size; ++i ) {
T( i ) = rng.normal();
}
assert(T.innerSize() == size);
assert(T.outerSize() == 1);
// LDT = (L D^1/2) * T
Vector LDT = LsD * T;
assert(LDT.innerSize() == size);
assert(LDT.outerSize() == 1);
// solution = means + LDT
Vector mean = distrib.mean();
assert(mean.innerSize() == size);
assert(mean.outerSize() == 1);
Vector typed_solution = mean + LDT;
assert(typed_solution.innerSize() == size);
assert(typed_solution.outerSize() == 1);
// copy in the EOT structure (more probably a vector)
EOT solution( size );
for( unsigned int i = 0; i < mean.innerSize(); i++ ) {
solution[i]= typed_solution(i);
}
assert( solution.size() == size );
return solution;
}
};
#endif // WITH_EIGEN
#endif // WITH_BOOST
#endif // !_edoSamplerNormalMulti_h #endif // !_edoSamplerNormalMulti_h

10
edo/src/utils/edoCholesky.h
View file

@ -27,6 +27,9 @@ Authors:
namespace cholesky { namespace cholesky {
#ifdef WITH_BOOST
/** Cholesky decomposition, given a matrix V, return a matrix L /** Cholesky decomposition, given a matrix V, return a matrix L
* such as V = L L^T (L^T being the transposed of L). * such as V = L L^T (L^T being the transposed of L).
* *
@ -282,4 +285,11 @@ public:
} }
}; };
#else
#ifdef WITH_EIGEN
#endif // WITH_EIGEN
#endif // WITH_BOOST
} // namespace cholesky } // namespace cholesky

36
edo/src/utils/edoStatNormalMulti.h
View file

@ -28,13 +28,24 @@ Authors:
#ifndef _edoStatNormalMulti_h #ifndef _edoStatNormalMulti_h
#define _edoStatNormalMulti_h #define _edoStatNormalMulti_h
#include <boost/numeric/ublas/io.hpp> #include<sstream>
#include "edoStat.h" #include "edoStat.h"
#include "edoNormalMulti.h" #include "edoNormalMulti.h"
//! edoStatNormalMulti< EOT > #ifdef WITH_BOOST
#include <boost/numeric/ublas/io.hpp>
#else
#ifdef WITH_EIGEN
// include nothing
#endif // WITH_EIGEN
#endif // WITH_BOOST
//! edoStatNormalMulti< EOT >
template < typename EOT > template < typename EOT >
class edoStatNormalMulti : public edoDistribStat< edoNormalMulti< EOT > > class edoStatNormalMulti : public edoDistribStat< edoNormalMulti< EOT > >
{ {
@ -44,27 +55,28 @@ public:
using edoDistribStat< edoNormalMulti< EOT > >::value; using edoDistribStat< edoNormalMulti< EOT > >::value;
edoStatNormalMulti( std::string desc = "" ) edoStatNormalMulti( std::string desc = "" )
: edoDistribStat< edoNormalMulti< EOT > >( desc ) : edoDistribStat< edoNormalMulti< EOT > >( desc )
{} {}
void operator()( const edoNormalMulti< EOT >& distrib ) void operator()( const edoNormalMulti< EOT >& distrib )
{ {
value() = "\n# ====== multi normal distribution dump =====\n"; value() = "\n# ====== multi normal distribution dump =====\n";
std::ostringstream os; std::ostringstream os;
os << distrib.mean() << " " << distrib.varcovar() << std::endl; os << distrib.mean() << std::endl << std::endl << distrib.varcovar() << std::endl;
// ublas::vector< AtomType > mean = distrib.mean(); // ublas::vector< AtomType > mean = distrib.mean();
// std::copy(mean.begin(), mean.end(), std::ostream_iterator< std::string >( os, " " )); // std::copy(mean.begin(), mean.end(), std::ostream_iterator< std::string >( os, " " ));
// ublas::symmetric_matrix< AtomType, ublas::lower > varcovar = distrib.varcovar(); // ublas::symmetric_matrix< AtomType, ublas::lower > varcovar = distrib.varcovar();
// std::copy(varcovar.begin(), varcovar.end(), std::ostream_iterator< std::string >( os, " " )); // std::copy(varcovar.begin(), varcovar.end(), std::ostream_iterator< std::string >( os, " " ));
// os << std::endl; // os << std::endl;
value() += os.str(); value() += os.str();
} }
}; };
#endif // !_edoStatNormalMulti_h #endif // !_edoStatNormalMulti_h

2
edo/test/CMakeLists.txt
View file

@ -33,7 +33,7 @@ LINK_DIRECTORIES(${Boost_LIBRARY_DIRS})
INCLUDE_DIRECTORIES(${CMAKE_SOURCE_DIR}/application/common) INCLUDE_DIRECTORIES(${CMAKE_SOURCE_DIR}/application/common)
SET(SOURCES SET(SOURCES
t-cholesky #t-cholesky
t-edoEstimatorNormalMulti t-edoEstimatorNormalMulti
t-mean-distance t-mean-distance
t-bounderno t-bounderno

149
edo/test/t-edoEstimatorNormalMulti.cpp
View file

@ -40,22 +40,29 @@ typedef eoReal< eoMinimizingFitness > EOT;
typedef edoNormalMulti< EOT > Distrib; typedef edoNormalMulti< EOT > Distrib;
typedef EOT::AtomType AtomType; typedef EOT::AtomType AtomType;
#ifdef WITH_BOOST
#include <boost/numeric/ublas/vector.hpp>
#include <boost/numeric/ublas/symmetric.hpp>
typedef ublas::vector< AtomType > Vector;
typedef ublas::symmetric_matrix< AtomType, ublas::lower > Matrix;
#else
#ifdef WITH_EIGEN
#include <Eigen/Dense>
typedef typename edoNormalMulti<EOT>::Vector Vector;
typedef typename edoNormalMulti<EOT>::Matrix Matrix;
#endif
#endif
int main(int ac, char** av) int main(int ac, char** av)
{ {
//-----------------------------------------------------
// (0) parser + eo routines // (0) parser + eo routines
//-----------------------------------------------------
eoParser parser(ac, av); eoParser parser(ac, av);
std::string section("Algorithm parameters"); std::string section("Algorithm parameters");
unsigned int p_size = parser.createParam((unsigned int)100, "popSize", "Population Size", 'P', section).value(); // P
unsigned int s_size = parser.createParam((unsigned int)2, "dimension-size", "Dimension size", 'd', section).value(); // d
AtomType mean_value = parser.createParam((AtomType)0, "mean", "Mean value", 'm', section).value(); // m
unsigned int p_size = parser.createParam((unsigned int)100, "popSize", "Population Size", 'P', section).value(); // P
unsigned int s_size = parser.createParam((unsigned int)2, "dimension-size", "Dimension size", 'd', section).value(); // d
AtomType mean_value = parser.createParam((AtomType)0, "mean", "Mean value", 'm', section).value(); // m
AtomType covar1_value = parser.createParam((AtomType)1.0, "covar1", "Covar value 1", '1', section).value(); AtomType covar1_value = parser.createParam((AtomType)1.0, "covar1", "Covar value 1", '1', section).value();
AtomType covar2_value = parser.createParam((AtomType)0.5, "covar2", "Covar value 2", '2', section).value(); AtomType covar2_value = parser.createParam((AtomType)0.5, "covar2", "Covar value 2", '2', section).value();
AtomType covar3_value = parser.createParam((AtomType)1.0, "covar3", "Covar value 3", '3', section).value(); AtomType covar3_value = parser.createParam((AtomType)1.0, "covar3", "Covar value 3", '3', section).value();
@ -66,29 +73,20 @@ int main(int ac, char** av)
<< covar3_value << "_gen"; << covar3_value << "_gen";
std::string gen_filename = ss.str(); std::string gen_filename = ss.str();
if (parser.userNeedsHelp()) if( parser.userNeedsHelp() ) {
{ parser.printHelp(std::cout);
parser.printHelp(std::cout); exit(1);
exit(1); }
}
make_verbose(parser); make_verbose(parser);
make_help(parser); make_help(parser);
assert(p_size > 0); assert(p_size > 0);
assert(s_size > 0); assert(s_size > 0);
eoState state; eoState state;
//-----------------------------------------------------
//-----------------------------------------------------
// (1) Population init and sampler // (1) Population init and sampler
//-----------------------------------------------------
eoRndGenerator< double >* gen = new eoUniformGenerator< double >(-5, 5); eoRndGenerator< double >* gen = new eoUniformGenerator< double >(-5, 5);
state.storeFunctor(gen); state.storeFunctor(gen);
@ -99,18 +97,14 @@ int main(int ac, char** av)
// fill population thanks to eoInit instance // fill population thanks to eoInit instance
eoPop< EOT >& pop = state.takeOwnership( eoPop< EOT >( p_size, *init ) ); eoPop< EOT >& pop = state.takeOwnership( eoPop< EOT >( p_size, *init ) );
//-----------------------------------------------------
//-----------------------------------------------------------------------------
// (2) distribution initial parameters // (2) distribution initial parameters
//----------------------------------------------------------------------------- Vector mean( s_size );
ublas::vector< AtomType > mean( s_size ); for (unsigned int i = 0; i < s_size; ++i) {
mean( i ) = mean_value;
}
for (unsigned int i = 0; i < s_size; ++i) { mean( i ) = mean_value; } Matrix varcovar( s_size, s_size );
ublas::symmetric_matrix< AtomType, ublas::lower > varcovar( s_size, s_size );
varcovar( 0, 0 ) = covar1_value; varcovar( 0, 0 ) = covar1_value;
varcovar( 0, 1 ) = covar2_value; varcovar( 0, 1 ) = covar2_value;
@ -118,13 +112,7 @@ int main(int ac, char** av)
Distrib distrib( mean, varcovar ); Distrib distrib( mean, varcovar );
//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
// (3a) distribution output preparation // (3a) distribution output preparation
//-----------------------------------------------------------------------------
edoDummyContinue< Distrib >* distrib_dummy_continue = new edoDummyContinue< Distrib >(); edoDummyContinue< Distrib >* distrib_dummy_continue = new edoDummyContinue< Distrib >();
state.storeFunctor(distrib_dummy_continue); state.storeFunctor(distrib_dummy_continue);
@ -141,60 +129,29 @@ int main(int ac, char** av)
distrib_file_snapshot->add(*distrib_stat); distrib_file_snapshot->add(*distrib_stat);
distrib_continue->add(*distrib_file_snapshot); distrib_continue->add(*distrib_file_snapshot);
//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
// (3b) distribution output // (3b) distribution output
//-----------------------------------------------------------------------------
(*distrib_continue)( distrib ); (*distrib_continue)( distrib );
//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
// Prepare bounder class to set bounds of sampling. // Prepare bounder class to set bounds of sampling.
// This is used by edoSampler. // This is used by edoSampler.
//----------------------------------------------------------------------------- edoBounder< EOT >* bounder = new edoBounderRng< EOT >(
EOT(pop[0].size(), -5), EOT(pop[0].size(), 5), *gen
edoBounder< EOT >* bounder = new edoBounderRng< EOT >(EOT(pop[0].size(), -5), );
EOT(pop[0].size(), 5),
*gen);
state.storeFunctor(bounder); state.storeFunctor(bounder);
//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
// Prepare sampler class with a specific distribution // Prepare sampler class with a specific distribution
//-----------------------------------------------------------------------------
edoSampler< Distrib >* sampler = new edoSamplerNormalMulti< EOT >( *bounder ); edoSampler< Distrib >* sampler = new edoSamplerNormalMulti< EOT >( *bounder );
state.storeFunctor(sampler); state.storeFunctor(sampler);
//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
// (4) sampling phase // (4) sampling phase
//-----------------------------------------------------------------------------
pop.clear(); pop.clear();
for (unsigned int i = 0; i < p_size; ++i) for( unsigned int i = 0; i < p_size; ++i ) {
{ EOT candidate_solution = (*sampler)( distrib );
EOT candidate_solution = (*sampler)( distrib ); pop.push_back( candidate_solution );
pop.push_back( candidate_solution ); }
}
//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
// (5) population output // (5) population output
//-----------------------------------------------------------------------------
eoContinue< EOT >* pop_cont = new eoGenContinue< EOT >( 2 ); // never reached fitness eoContinue< EOT >* pop_cont = new eoGenContinue< EOT >( 2 ); // never reached fitness
state.storeFunctor(pop_cont); state.storeFunctor(pop_cont);
@ -212,53 +169,31 @@ int main(int ac, char** av)
(*pop_continue)( pop ); (*pop_continue)( pop );
//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
// (6) estimation phase // (6) estimation phase
//-----------------------------------------------------------------------------
edoEstimator< Distrib >* estimator = new edoEstimatorNormalMulti< EOT >(); edoEstimator< Distrib >* estimator = new edoEstimatorNormalMulti< EOT >();
state.storeFunctor(estimator); state.storeFunctor(estimator);
distrib = (*estimator)( pop ); distrib = (*estimator)( pop );
//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
// (7) distribution output // (7) distribution output
//-----------------------------------------------------------------------------
(*distrib_continue)( distrib ); (*distrib_continue)( distrib );
//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
// (8) euclidianne distance estimation // (8) euclidianne distance estimation
//----------------------------------------------------------------------------- Vector new_mean = distrib.mean();
Matrix new_varcovar = distrib.varcovar();
ublas::vector< AtomType > new_mean = distrib.mean();
ublas::symmetric_matrix< AtomType, ublas::lower > new_varcovar = distrib.varcovar();
AtomType distance = 0; AtomType distance = 0;
for( unsigned int d = 0; d < s_size; ++d ) {
for ( unsigned int d = 0; d < s_size; ++d ) distance += pow( mean[ d ] - new_mean[ d ], 2 );
{ }
distance += pow( mean[ d ] - new_mean[ d ], 2 );
}
distance = sqrt( distance ); distance = sqrt( distance );
eo::log << eo::logging eo::log << eo::logging
<< "mean: " << mean << std::endl << "mean: " << mean << std::endl
<< "new mean: " << new_mean << std::endl << "new mean: " << new_mean << std::endl
<< "distance: " << distance << std::endl << "distance: " << distance << std::endl
; ;
//-----------------------------------------------------------------------------
return 0; return 0;
} }

233
edo/test/t-mean-distance.cpp
View file

@ -37,25 +37,33 @@ Authors:
#include <edo> #include <edo>
#include <boost/numeric/ublas/vector.hpp>
#include <boost/numeric/ublas/symmetric.hpp>
#include "Rosenbrock.h" #include "Rosenbrock.h"
#include "Sphere.h" #include "Sphere.h"
typedef eoReal< eoMinimizingFitness > EOT; typedef eoReal< eoMinimizingFitness > EOT;
typedef edoNormalMulti< EOT > Distrib; typedef edoNormalMulti< EOT > Distrib;
typedef EOT::AtomType AtomType; typedef typename EOT::AtomType AtomType;
#ifdef WITH_BOOST
#include <boost/numeric/ublas/vector.hpp>
#include <boost/numeric/ublas/symmetric.hpp>
typedef ublas::vector< AtomType > Vector;
typedef ublas::symmetric_matrix< AtomType, ublas::lower > Matrix;
#else
#ifdef WITH_EIGEN
#include <Eigen/Dense>
typedef typename edoNormalMulti<EOT>::Vector Vector;
typedef typename edoNormalMulti<EOT>::Matrix Matrix;
#endif
#endif
int main(int ac, char** av) int main(int ac, char** av)
{ {
//-----------------------------------------------------
// (0) parser + eo routines // (0) parser + eo routines
//-----------------------------------------------------
eoParser parser(ac, av); eoParser parser(ac, av);
std::string section("Algorithm parameters"); std::string section("Algorithm parameters");
unsigned int r_max = parser.createParam((unsigned int)100, "run-number", "Number of run", 'r', section).value(); // r unsigned int r_max = parser.createParam((unsigned int)100, "run-number", "Number of run", 'r', section).value(); // r
unsigned int p_min = parser.createParam((unsigned int)10, "population-min", "Population min", 'p', section).value(); // p unsigned int p_min = parser.createParam((unsigned int)10, "population-min", "Population min", 'p', section).value(); // p
@ -72,15 +80,15 @@ int main(int ac, char** av)
std::string files_description = parser.createParam((std::string)"files_description.txt", "files-description", "Files description", 'F', section).value(); // F std::string files_description = parser.createParam((std::string)"files_description.txt", "files-description", "Files description", 'F', section).value(); // F
if (parser.userNeedsHelp()) if (parser.userNeedsHelp())
{ {
parser.printHelp(std::cout); parser.printHelp(std::cout);
exit(1); exit(1);
} }
make_verbose(parser); make_verbose(parser);
make_help(parser); make_help(parser);
//-----------------------------------------------------
assert(r_max >= 1); assert(r_max >= 1);
assert(s_size >= 2); assert(s_size >= 2);
@ -90,139 +98,146 @@ int main(int ac, char** av)
::mkdir( results_directory.c_str(), 0755 ); ::mkdir( results_directory.c_str(), 0755 );
for ( unsigned int p_size = p_min; p_size <= p_max; p_size += p_step ) for ( unsigned int p_size = p_min; p_size <= p_max; p_size += p_step )
{ {
assert(p_size >= p_min); assert(p_size >= p_min);
std::ostringstream desc_file; std::ostringstream desc_file;
desc_file << results_directory << "/" << files_description; desc_file << results_directory << "/" << files_description;
std::ostringstream cur_file; std::ostringstream cur_file;
cur_file << results_directory << "/pop_" << p_size << ".txt"; cur_file << results_directory << "/pop_" << p_size << ".txt";
eo::log << eo::file( desc_file.str() ) << cur_file.str().c_str() << std::endl; eo::log << eo::file( desc_file.str() ) << cur_file.str().c_str() << std::endl;
eo::log << eo::file( cur_file.str() ); eo::log << eo::file( cur_file.str() );
eo::log << eo::logging << "run_number p_size s_size mean(0) mean(1) new-mean(0) new-mean(1) distance" << std::endl; eo::log << eo::logging << "run_number p_size s_size mean(0) mean(1) new-mean(0) new-mean(1) distance" << std::endl;
eo::log << eo::quiet; eo::log << eo::quiet;
for ( unsigned int r = 1; r <= r_max; ++r) for ( unsigned int r = 1; r <= r_max; ++r)
{ {
eoState state; eoState state;
//-----------------------------------------------------
// (1) Population init and sampler
//-----------------------------------------------------
eoRndGenerator< double >* gen = new eoUniformGenerator< double >(-5, 5); // (1) Population init and sampler
state.storeFunctor(gen);
eoInitFixedLength< EOT >* init = new eoInitFixedLength< EOT >( s_size, *gen );
state.storeFunctor(init);
// create an empty pop and let the state handle the memory
// fill population thanks to eoInit instance
eoPop< EOT >& pop = state.takeOwnership( eoPop< EOT >( p_size, *init ) );
//-----------------------------------------------------
//----------------------------------------------------------------------------- eoRndGenerator< double >* gen = new eoUniformGenerator< double >(-5, 5);
// (2) distribution initial parameters state.storeFunctor(gen);
//-----------------------------------------------------------------------------
ublas::vector< AtomType > mean( s_size, mean_value ); eoInitFixedLength< EOT >* init = new eoInitFixedLength< EOT >( s_size, *gen );
ublas::symmetric_matrix< AtomType, ublas::lower > varcovar( s_size, s_size ); state.storeFunctor(init);
varcovar( 0, 0 ) = covar1_value; // create an empty pop and let the state handle the memory
varcovar( 0, 1 ) = covar2_value; // fill population thanks to eoInit instance
varcovar( 1, 1 ) = covar3_value; eoPop< EOT >& pop = state.takeOwnership( eoPop< EOT >( p_size, *init ) );
Distrib distrib( mean, varcovar );
//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
// Prepare bounder class to set bounds of sampling.
// This is used by edoSampler.
//-----------------------------------------------------------------------------
edoBounder< EOT >* bounder = new edoBounderRng< EOT >(EOT(pop[0].size(), -5),
EOT(pop[0].size(), 5),
*gen);
state.storeFunctor(bounder);
//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
// Prepare sampler class with a specific distribution
//-----------------------------------------------------------------------------
edoSampler< Distrib >* sampler = new edoSamplerNormalMulti< EOT >( *bounder ); // (2) distribution initial parameters
state.storeFunctor(sampler);
//-----------------------------------------------------------------------------
//----------------------------------------------------------------------------- #ifdef WITH_BOOST
// (4) sampling phase Vector mean( s_size, mean_value );
//----------------------------------------------------------------------------- #else
#ifdef WITH_EIGEN
Vector mean( s_size );
mean = Vector::Constant( s_size, mean_value);
#endif
#endif
Matrix varcovar( s_size, s_size );
pop.clear(); varcovar( 0, 0 ) = covar1_value;
varcovar( 0, 1 ) = covar2_value;
varcovar( 1, 1 ) = covar3_value;
for (unsigned int i = 0; i < p_size; ++i) Distrib distrib( mean, varcovar );
{
EOT candidate_solution = (*sampler)( distrib );
pop.push_back( candidate_solution );
}
//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
// (6) estimation phase
//-----------------------------------------------------------------------------
edoEstimator< Distrib >* estimator = new edoEstimatorNormalMulti< EOT >();
state.storeFunctor(estimator);
distrib = (*estimator)( pop );
//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
// (8) euclidianne distance estimation
//-----------------------------------------------------------------------------
ublas::vector< AtomType > new_mean = distrib.mean(); // Prepare bounder class to set bounds of sampling.
ublas::symmetric_matrix< AtomType, ublas::lower > new_varcovar = distrib.varcovar(); // This is used by edoSampler.
AtomType distance = 0;
for ( unsigned int d = 0; d < s_size; ++d ) edoBounder< EOT >* bounder = new edoBounderRng< EOT >(EOT(pop[0].size(), -5),
{ EOT(pop[0].size(), 5),
distance += pow( mean[ d ] - new_mean[ d ], 2 ); *gen);
} state.storeFunctor(bounder);
distance = sqrt( distance );
eo::log << r << " " << p_size << " " << s_size << " "
<< mean(0) << " " << mean(1) << " "
<< new_mean(0) << " " << new_mean(1) << " "
<< distance << std::endl
;
//-----------------------------------------------------------------------------
}
} // Prepare sampler class with a specific distribution
edoSampler< Distrib >* sampler = new edoSamplerNormalMulti< EOT >( *bounder );
state.storeFunctor(sampler);
// (4) sampling phase
pop.clear();
for (unsigned int i = 0; i < p_size; ++i)
{
EOT candidate_solution = (*sampler)( distrib );
pop.push_back( candidate_solution );
}
// (6) estimation phase
edoEstimator< Distrib >* estimator = new edoEstimatorNormalMulti< EOT >();
state.storeFunctor(estimator);
distrib = (*estimator)( pop );
// (8) euclidianne distance estimation
Vector new_mean = distrib.mean();
Matrix new_varcovar = distrib.varcovar();
AtomType distance = 0;
for ( unsigned int d = 0; d < s_size; ++d )
{
distance += pow( mean[ d ] - new_mean[ d ], 2 );
}
distance = sqrt( distance );
eo::log << r << " " << p_size << " " << s_size << " "
<< mean(0) << " " << mean(1) << " "
<< new_mean(0) << " " << new_mean(1) << " "
<< distance << std::endl
;
}
}
return 0; return 0;
} }

12
eo/install_symlink.py.cmake
View file

@ -31,8 +31,16 @@ def uninstall():
print('All symlinks have been removed.') print('All symlinks have been removed.')
def install(): def install():
for dirname in DATA['dirs']: os.mkdir(dirname) for dirname in DATA['dirs']:
for src, dst in DATA['links']: os.symlink(src, dst) try:
os.makedirs(dirname)
except(os.error):
pass
for src, dst in DATA['links']:
try:
os.symlink(src, dst)
except:
pass
print('All symlinks have been installed.') print('All symlinks have been installed.')
def data(): def data():

3
eo/src/apply.h
View file

@ -31,7 +31,10 @@
#include <utils/eoLogger.h> #include <utils/eoLogger.h>
#include <eoFunctor.h> #include <eoFunctor.h>
#include <vector> #include <vector>
#ifdef _OPENMP
#include <omp.h> #include <omp.h>
#endif
/** /**
Applies a unary function to a std::vector of things. Applies a unary function to a std::vector of things.

607
eo/src/do/make_checkpoint.h
View file

@ -1,45 +1,32 @@
// -*- mode: c++; c-indent-level: 4; c++-member-init-indent: 8; comment-column: 35; -*- // -*- mode: c++; c-indent-level: 4; c++-member-init-indent: 8; comment-column: 35; -*-
//----------------------------------------------------------------------------- //-----------------------------------------------------------------------------
// make_checkpoint.h // make_checkpoint.h
// (c) Maarten Keijzer, Marc Schoenauer and GeNeura Team, 2000 // (c) Maarten Keijzer, Marc Schoenauer and GeNeura Team, 2000
/* /*
This library is free software; you can redistribute it and/or This library is free software; you can redistribute it and/or
modify it under the terms of the GNU Lesser General Public modify it under the terms of the GNU Lesser General Public
License as published by the Free Software Foundation; either License as published by the Free Software Foundation; either
version 2 of the License, or (at your option) any later version. version 2 of the License, or (at your option) any later version.
This library is distributed in the hope that it will be useful, This library is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
Lesser General Public License for more details. Lesser General Public License for more details.
You should have received a copy of the GNU Lesser General Public You should have received a copy of the GNU Lesser General Public
License along with this library; if not, write to the Free Software License along with this library; if not, write to the Free Software
Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
Contact: todos@geneura.ugr.es, http://geneura.ugr.es
Marc.Schoenauer@polytechnique.fr
mkeijzer@dhi.dk
*/
Contact: todos@geneura.ugr.es, http://geneura.ugr.es
Marc.Schoenauer@polytechnique.fr
mkeijzer@dhi.dk
*/
//----------------------------------------------------------------------------- //-----------------------------------------------------------------------------
#ifndef _make_checkpoint_h #ifndef _make_checkpoint_h
#define _make_checkpoint_h #define _make_checkpoint_h
#ifdef HAVE_CONFIG_H #ifdef HAVE_CONFIG_H
#include <config.h> #include <config.h>
#endif #endif
@ -52,521 +39,315 @@
#include <eoEvalFuncCounter.h> #include <eoEvalFuncCounter.h>
#include <utils/checkpointing> #include <utils/checkpointing>
// at the moment, in utils/make_help.cpp // at the moment, in utils/make_help.cpp
// this should become some eoUtils.cpp with corresponding eoUtils.h // this should become some eoUtils.cpp with corresponding eoUtils.h
bool testDirRes(std::string _dirName, bool _erase); bool testDirRes(std::string _dirName, bool _erase);
/////////////////// The checkpoint and other I/O ////////////// /////////////////// The checkpoint and other I/O //////////////
/** /**
* *
* CHANGE (March 2008): now receiving an eoValueParam instead of an eoEvalFuncCounter. This function is just interested * CHANGE (March 2008): now receiving an eoValueParam instead of an eoEvalFuncCounter. This function is just interested
* in the value of the parameter calculated on the evaluation function, not in the actual function itself!! * in the value of the parameter calculated on the evaluation function, not in the actual function itself!!
* *
* @ingroup Builders * @ingroup Builders
*/ */
template <class EOT> template <class EOT>
eoCheckPoint<EOT>& do_make_checkpoint(eoParser& _parser, eoState& _state, eoValueParam<unsigned long>& _eval, eoContinue<EOT>& _continue) eoCheckPoint<EOT>& do_make_checkpoint(eoParser& _parser, eoState& _state, eoValueParam<unsigned long>& _eval, eoContinue<EOT>& _continue)
{ {
// first, create a checkpoint from the eoContinue
eoCheckPoint<EOT> *checkpoint = new eoCheckPoint<EOT>(_continue);
// first, create a checkpoint from the eoContinue _state.storeFunctor(checkpoint);
eoCheckPoint<EOT> *checkpoint = new eoCheckPoint<EOT>(_continue);
_state.storeFunctor(checkpoint); ////////////////////
// Signal monitoring
////////////////////
#ifndef _MSC_VER
// the CtrlC monitoring interception
eoSignal<EOT> *mon_ctrlCCont;
eoValueParam<bool>& mon_ctrlCParam = _parser.createParam(false, "monitor-with-CtrlC", "Monitor current generation upon Ctrl C",0, "Stopping criterion");
if (mon_ctrlCParam.value())
{
mon_ctrlCCont = new eoSignal<EOT>;
// store
_state.storeFunctor(mon_ctrlCCont);
// add to checkpoint
checkpoint->add(*mon_ctrlCCont);
}
#endif
///////////////////
// Counters
//////////////////
/////////////////// // is nb Eval to be used as counter?
eoValueParam<bool>& useEvalParam = _parser.createParam(true, "useEval", "Use nb of eval. as counter (vs nb of gen.)", '\0', "Output");
eoValueParam<bool>& useTimeParam = _parser.createParam(true, "useTime", "Display time (s) every generation", '\0', "Output");
// if we want the time, we need an eoTimeCounter
eoTimeCounter * tCounter = NULL;
// Counters // Create anyway a generation-counter
// Recent change (03/2002): it is now an eoIncrementorParam, both
////////////////// // a parameter AND updater so you can store it into the eoState
eoIncrementorParam<unsigned> *generationCounter = new eoIncrementorParam<unsigned>("Gen.");
// is nb Eval to be used as counter?
eoValueParam<bool>& useEvalParam = _parser.createParam(true, "useEval", "Use nb of eval. as counter (vs nb of gen.)", '\0', "Output");
eoValueParam<bool>& useTimeParam = _parser.createParam(true, "useTime", "Display time (s) every generation", '\0', "Output");
// if we want the time, we need an eoTimeCounter
eoTimeCounter * tCounter = NULL;
// Create anyway a generation-counter
// Recent change (03/2002): it is now an eoIncrementorParam, both
// a parameter AND updater so you can store it into the eoState
eoIncrementorParam<unsigned> *generationCounter = new eoIncrementorParam<unsigned>("Gen.");
// store it in the state
_state.storeFunctor(generationCounter);
// And add it to the checkpoint,
checkpoint->add(*generationCounter);
// store it in the state
_state.storeFunctor(generationCounter);
// And add it to the checkpoint,
checkpoint->add(*generationCounter);
// dir for DISK output // dir for DISK output
eoValueParam<std::string>& dirNameParam = _parser.createParam(std::string("Res"), "resDir", "Directory to store DISK outputs", '\0', "Output - Disk"); eoValueParam<std::string>& dirNameParam = _parser.createParam(std::string("Res"), "resDir", "Directory to store DISK outputs", '\0', "Output - Disk");
// shoudl we empty it if exists // shoudl we empty it if exists
eoValueParam<bool>& eraseParam = _parser.createParam(true, "eraseDir", "erase files in dirName if any", '\0', "Output - Disk"); eoValueParam<bool>& eraseParam = _parser.createParam(true, "eraseDir", "erase files in dirName if any", '\0', "Output - Disk");
bool dirOK = false; // not tested yet bool dirOK = false; // not tested yet
///////////////////////////////////////// /////////////////////////////////////////
// now some statistics on the population: // now some statistics on the population:
///////////////////////////////////////// /////////////////////////////////////////
/** /**
* existing stats as of today, April 10. 2001 * existing stats as of today, April 10. 2001
* *
* eoBestFitnessStat : best value in pop - type EOT::Fitness * eoBestFitnessStat : best value in pop - type EOT::Fitness
* eoAverageStat : average value in pop - type EOT::Fitness * eoAverageStat : average value in pop - type EOT::Fitness
* eoSecondMomentStat: average + stdev - type std::pair<double, double> * eoSecondMomentStat: average + stdev - type std::pair<double, double>
* eoSortedPopStat : whole population - type std::string (!!) * eoSortedPopStat : whole population - type std::string (!!)
* eoScalarFitnessStat: the fitnesses - type std::vector<double> * eoScalarFitnessStat: the fitnesses - type std::vector<double>
*/ */
// Best fitness in population // Best fitness in population
//--------------------------- //---------------------------
eoValueParam<bool>& printBestParam = _parser.createParam(true, "printBestStat", "Print Best/avg/stdev every gen.", '\0', "Output"); eoValueParam<bool>& printBestParam = _parser.createParam(true, "printBestStat", "Print Best/avg/stdev every gen.", '\0', "Output");
eoValueParam<bool>& plotBestParam = _parser.createParam(false, "plotBestStat", "Plot Best/avg Stat", '\0', "Output - Graphical"); eoValueParam<bool>& plotBestParam = _parser.createParam(false, "plotBestStat", "Plot Best/avg Stat", '\0', "Output - Graphical");
eoValueParam<bool>& fileBestParam = _parser.createParam(false, "fileBestStat", "Output bes/avg/std to file", '\0', "Output - Disk"); eoValueParam<bool>& fileBestParam = _parser.createParam(false, "fileBestStat", "Output bes/avg/std to file", '\0', "Output - Disk");
eoBestFitnessStat<EOT> *bestStat = NULL; eoBestFitnessStat<EOT> *bestStat = NULL;
if ( printBestParam.value() || plotBestParam.value() || fileBestParam.value() ) if ( printBestParam.value() || plotBestParam.value() || fileBestParam.value() )
// we need the bestStat for at least one of the 3 above
// we need the bestStat for at least one of the 3 above {
bestStat = new eoBestFitnessStat<EOT>;
{ // store it
_state.storeFunctor(bestStat);
bestStat = new eoBestFitnessStat<EOT>; // add it to the checkpoint
checkpoint->add(*bestStat);
// store it // check if monitoring with signal
if ( mon_ctrlCParam.value() )
_state.storeFunctor(bestStat); mon_ctrlCCont->add(*bestStat);
}
// add it to the checkpoint
checkpoint->add(*bestStat);
}
// Average fitness alone // Average fitness alone
//---------------------- //----------------------
eoAverageStat<EOT> *averageStat = NULL; // do we need averageStat? eoAverageStat<EOT> *averageStat = NULL; // do we need averageStat?
if ( printBestParam.value() || plotBestParam.value() || fileBestParam.value() ) // we need it for gnuplot output
if ( plotBestParam.value() ) // we need it for gnuplot output {
averageStat = new eoAverageStat<EOT>;
{ // store it
_state.storeFunctor(averageStat);
averageStat = new eoAverageStat<EOT>; // add it to the checkpoint
checkpoint->add(*averageStat);
// store it // check if monitoring with signal
if ( mon_ctrlCParam.value() )
_state.storeFunctor(averageStat); mon_ctrlCCont->add(*averageStat);
}
// add it to the checkpoint
checkpoint->add(*averageStat);
}
// Second moment stats: average and stdev // Second moment stats: average and stdev
//--------------------------------------- //---------------------------------------
eoSecondMomentStats<EOT> *secondStat = NULL; eoSecondMomentStats<EOT> *secondStat = NULL;
if ( printBestParam.value() || fileBestParam.value() ) // we need it for screen output or file output
if ( printBestParam.value() || fileBestParam.value() ) // we need it for screen output or file output {
secondStat = new eoSecondMomentStats<EOT>;
{ // store it
_state.storeFunctor(secondStat);
secondStat = new eoSecondMomentStats<EOT>; // add it to the checkpoint
checkpoint->add(*secondStat);
// store it // check if monitoring with signal
if ( mon_ctrlCParam.value() )
_state.storeFunctor(secondStat); mon_ctrlCCont->add(*secondStat);
}
// add it to the checkpoint
checkpoint->add(*secondStat);
}
// Dump of the whole population // Dump of the whole population
//----------------------------- //-----------------------------
eoSortedPopStat<EOT> *popStat = NULL; eoSortedPopStat<EOT> *popStat = NULL;
eoValueParam<bool>& printPopParam = _parser.createParam(false, "printPop", "Print sorted pop. every gen.", '\0', "Output"); eoValueParam<bool>& printPopParam = _parser.createParam(false, "printPop", "Print sorted pop. every gen.", '\0', "Output");
if ( printPopParam.value() ) // we do want pop dump if ( printPopParam.value() ) // we do want pop dump
{
{ popStat = new eoSortedPopStat<EOT>;
// store it
popStat = new eoSortedPopStat<EOT>; _state.storeFunctor(popStat);
// add it to the checkpoint
// store it checkpoint->add(*popStat);
// check if monitoring with signal
_state.storeFunctor(popStat); if ( mon_ctrlCParam.value() )
mon_ctrlCCont->add(*popStat);
// add it to the checkpoint }
checkpoint->add(*popStat);
}
// do we wnat some histogram of fitnesses snpashots? // do we wnat some histogram of fitnesses snpashots?
eoValueParam<bool> plotHistogramParam = _parser.createParam(false, "plotHisto", "Plot histogram of fitnesses", '\0', "Output - Graphical"); eoValueParam<bool> plotHistogramParam = _parser.createParam(false, "plotHisto", "Plot histogram of fitnesses", '\0', "Output - Graphical");
/////////////// ///////////////
// The monitors // The monitors
/////////////// ///////////////
// do we want an eoStdoutMonitor? // do we want an eoStdoutMonitor?
bool needStdoutMonitor = printBestParam.value() bool needStdoutMonitor = printBestParam.value()
|| printPopParam.value() ; || printPopParam.value() ;
// The Stdout monitor will print parameters to the screen ... // The Stdout monitor will print parameters to the screen ...
if ( needStdoutMonitor ) if ( needStdoutMonitor )
{
eoStdoutMonitor *monitor = new eoStdoutMonitor(/*false FIXME remove this deprecated prototype*/);
_state.storeFunctor(monitor);
{ // when called by the checkpoint (i.e. at every generation)
// check if monitoring with signal
if ( ! mon_ctrlCParam.value() )
checkpoint->add(*monitor);
else
mon_ctrlCCont->add(*monitor);
eoStdoutMonitor *monitor = new eoStdoutMonitor(false); // the monitor will output a series of parameters: add them
monitor->add(*generationCounter);
_state.storeFunctor(monitor); if (useEvalParam.value()) // we want nb of evaluations
monitor->add(_eval);
if (useTimeParam.value()) // we want time
{
// when called by the checkpoint (i.e. at every generation) tCounter = new eoTimeCounter;
_state.storeFunctor(tCounter);
checkpoint->add(*monitor); // check if monitoring with signal
if ( ! mon_ctrlCParam.value() )
checkpoint->add(*tCounter);
else
// the monitor will output a series of parameters: add them mon_ctrlCCont->add(*tCounter);
monitor->add(*tCounter);
monitor->add(*generationCounter); }
if (useEvalParam.value()) // we want nb of evaluations
monitor->add(_eval);
if (useTimeParam.value()) // we want time
{
tCounter = new eoTimeCounter;
_state.storeFunctor(tCounter);
checkpoint->add(*tCounter);
monitor->add(*tCounter);
}
if (printBestParam.value())
{
monitor->add(*bestStat);
monitor->add(*secondStat);
}
if ( printPopParam.value())
monitor->add(*popStat);
}
if (printBestParam.value())
{
monitor->add(*bestStat);
monitor->add(*secondStat);
}
if ( printPopParam.value())
monitor->add(*popStat);
}
// first handle the dir test - if we need at least one file // first handle the dir test - if we need at least one file
if ( ( fileBestParam.value() || plotBestParam.value() || if ( ( fileBestParam.value() || plotBestParam.value() ||
plotHistogramParam.value() ) plotHistogramParam.value() )
&& !dirOK ) // just in case we add something before && !dirOK ) // just in case we add something before
dirOK = testDirRes(dirNameParam.value(), eraseParam.value()); // TRUE
dirOK = testDirRes(dirNameParam.value(), eraseParam.value()); // TRUE
if (fileBestParam.value()) // A file monitor for best & secondMoment if (fileBestParam.value()) // A file monitor for best & secondMoment
{
{
#ifdef _MSVC #ifdef _MSVC
std::string stmp = dirNameParam.value() + "\best.xg";
std::string stmp = dirNameParam.value() + "\best.xg";
#else #else
std::string stmp = dirNameParam.value() + "/best.xg";
std::string stmp = dirNameParam.value() + "/best.xg";
#endif #endif
eoFileMonitor *fileMonitor = new eoFileMonitor(stmp);
eoFileMonitor *fileMonitor = new eoFileMonitor(stmp); // save and give to checkpoint
_state.storeFunctor(fileMonitor);
// save and give to checkpoint checkpoint->add(*fileMonitor);
// and feed with some statistics
_state.storeFunctor(fileMonitor); fileMonitor->add(*generationCounter);
fileMonitor->add(_eval);
checkpoint->add(*fileMonitor); if (tCounter) // we want the time as well
{
// and feed with some statistics // std::cout << "On met timecounter\n";
fileMonitor->add(*tCounter);
fileMonitor->add(*generationCounter); }
fileMonitor->add(*bestStat);
fileMonitor->add(_eval); fileMonitor->add(*secondStat);
}
if (tCounter) // we want the time as well
{
// std::cout << "On met timecounter\n";
fileMonitor->add(*tCounter);
}
fileMonitor->add(*bestStat);
fileMonitor->add(*secondStat);
}
#if defined(HAVE_GNUPLOT) #if defined(HAVE_GNUPLOT)
if (plotBestParam.value()) // an eoGnuplot1DMonitor for best & average if (plotBestParam.value()) // an eoGnuplot1DMonitor for best & average
{
{ std::string stmp = dirNameParam.value() + "/gnu_best.xg";
eoGnuplot1DMonitor *gnuMonitor = new eoGnuplot1DMonitor(stmp,minimizing_fitness<EOT>());
std::string stmp = dirNameParam.value() + "/gnu_best.xg"; // save and give to checkpoint
_state.storeFunctor(gnuMonitor);
eoGnuplot1DMonitor *gnuMonitor = new eoGnuplot1DMonitor(stmp,minimizing_fitness<EOT>()); checkpoint->add(*gnuMonitor);
// and feed with some statistics
// save and give to checkpoint if (useEvalParam.value()) // do we want eval as X coordinate
gnuMonitor->add(_eval);
_state.storeFunctor(gnuMonitor); else if (tCounter) // or time?
gnuMonitor->add(*tCounter);
checkpoint->add(*gnuMonitor); else // default: generation
gnuMonitor->add(*generationCounter);
// and feed with some statistics gnuMonitor->add(*bestStat);
gnuMonitor->add(*averageStat);
if (useEvalParam.value()) // do we want eval as X coordinate }
gnuMonitor->add(_eval);
else if (tCounter) // or time?
gnuMonitor->add(*tCounter);
else // default: generation
gnuMonitor->add(*generationCounter);
gnuMonitor->add(*bestStat);
gnuMonitor->add(*averageStat);
}
// historgram? // historgram?
if (plotHistogramParam.value()) // want to see how the fitness is spread? if (plotHistogramParam.value()) // want to see how the fitness is spread?
{
{ eoScalarFitnessStat<EOT> *fitStat = new eoScalarFitnessStat<EOT>;
_state.storeFunctor(fitStat);
eoScalarFitnessStat<EOT> *fitStat = new eoScalarFitnessStat<EOT>; checkpoint->add(*fitStat);
// a gnuplot-based monitor for snapshots: needs a dir name
_state.storeFunctor(fitStat); eoGnuplot1DSnapshot *fitSnapshot = new eoGnuplot1DSnapshot(dirNameParam.value());
_state.storeFunctor(fitSnapshot);
checkpoint->add(*fitStat); // add any stat that is a std::vector<double> to it
fitSnapshot->add(*fitStat);
// a gnuplot-based monitor for snapshots: needs a dir name // and of course add it to the checkpoint
checkpoint->add(*fitSnapshot);
eoGnuplot1DSnapshot *fitSnapshot = new eoGnuplot1DSnapshot(dirNameParam.value()); }
_state.storeFunctor(fitSnapshot);
// add any stat that is a std::vector<double> to it
fitSnapshot->add(*fitStat);
// and of course add it to the checkpoint
checkpoint->add(*fitSnapshot);
}
#endif #endif
////////////////////////////////// //////////////////////////////////
// State savers // State savers
////////////////////////////// //////////////////////////////
// feed the state to state savers // feed the state to state savers
// save state every N generation // save state every N generation
eoValueParam<unsigned>& saveFrequencyParam = _parser.createParam(unsigned(0), "saveFrequency", "Save every F generation (0 = only final state, absent = never)", '\0', "Persistence" ); eoValueParam<unsigned>& saveFrequencyParam = _parser.createParam(unsigned(0), "saveFrequency", "Save every F generation (0 = only final state, absent = never)", '\0', "Persistence" );
if (_parser.isItThere(saveFrequencyParam)) if (_parser.isItThere(saveFrequencyParam))
{
// first make sure dirName is OK
if (! dirOK )
dirOK = testDirRes(dirNameParam.value(), eraseParam.value()); // TRUE
{ unsigned freq = (saveFrequencyParam.value()>0 ? saveFrequencyParam.value() : UINT_MAX );
// first make sure dirName is OK
if (! dirOK )
dirOK = testDirRes(dirNameParam.value(), eraseParam.value()); // TRUE
unsigned freq = (saveFrequencyParam.value()>0 ? saveFrequencyParam.value() : UINT_MAX );
#ifdef _MSVC #ifdef _MSVC
std::string stmp = dirNameParam.value() + "\generations";
std::string stmp = dirNameParam.value() + "\generations";
#else #else
std::string stmp = dirNameParam.value() + "/generations";
std::string stmp = dirNameParam.value() + "/generations";
#endif #endif
eoCountedStateSaver *stateSaver1 = new eoCountedStateSaver(freq, _state, stmp);
eoCountedStateSaver *stateSaver1 = new eoCountedStateSaver(freq, _state, stmp); _state.storeFunctor(stateSaver1);
checkpoint->add(*stateSaver1);
_state.storeFunctor(stateSaver1); }
checkpoint->add(*stateSaver1);
}
// save state every T seconds // save state every T seconds
eoValueParam<unsigned>& saveTimeIntervalParam = _parser.createParam(unsigned(0), "saveTimeInterval", "Save every T seconds (0 or absent = never)", '\0',"Persistence" ); eoValueParam<unsigned>& saveTimeIntervalParam = _parser.createParam(unsigned(0), "saveTimeInterval", "Save every T seconds (0 or absent = never)", '\0',"Persistence" );
if (_parser.isItThere(saveTimeIntervalParam) && saveTimeIntervalParam.value()>0) if (_parser.isItThere(saveTimeIntervalParam) && saveTimeIntervalParam.value()>0)
{
{ // first make sure dirName is OK
if (! dirOK )
// first make sure dirName is OK dirOK = testDirRes(dirNameParam.value(), eraseParam.value()); // TRUE
if (! dirOK )
dirOK = testDirRes(dirNameParam.value(), eraseParam.value()); // TRUE
#ifdef _MSVC #ifdef _MSVC
std::string stmp = dirNameParam.value() + "\time";
std::string stmp = dirNameParam.value() + "\time";
#else #else
std::string stmp = dirNameParam.value() + "/time";
std::string stmp = dirNameParam.value() + "/time";
#endif #endif
eoTimedStateSaver *stateSaver2 = new eoTimedStateSaver(saveTimeIntervalParam.value(), _state, stmp);
eoTimedStateSaver *stateSaver2 = new eoTimedStateSaver(saveTimeIntervalParam.value(), _state, stmp); _state.storeFunctor(stateSaver2);
checkpoint->add(*stateSaver2);
_state.storeFunctor(stateSaver2); }
checkpoint->add(*stateSaver2);
}
// and that's it for the (control and) output // and that's it for the (control and) output
return *checkpoint; return *checkpoint;
} }
#endif #endif

2
eo/src/do/make_checkpoint_FDC.h
View file

@ -175,7 +175,7 @@ eoCheckPoint<EOT>& do_make_checkpoint(eoParser& _parser, eoState& _state, eoEval
// The Stdout monitor will print parameters to the screen ... // The Stdout monitor will print parameters to the screen ...
if ( needStdoutMonitor ) if ( needStdoutMonitor )
{ {
eoStdoutMonitor *monitor = new eoStdoutMonitor(false); eoStdoutMonitor *monitor = new eoStdoutMonitor(/*false FIXME remove this deprecated prototype*/);
_state.storeFunctor(monitor); _state.storeFunctor(monitor);
// when called by the checkpoint (i.e. at every generation) // when called by the checkpoint (i.e. at every generation)

2
eo/src/do/make_checkpoint_assembled.h
View file

@ -129,7 +129,7 @@ eoCheckPoint<EOT>& do_make_checkpoint_assembled(eoParser& _parser, eoState& _sta
// STDOUT // STDOUT
// ------ // ------
eoStdoutMonitor *monitor = new eoStdoutMonitor(false); eoStdoutMonitor *monitor = new eoStdoutMonitor(/*false FIXME remove this deprecated prototype*/);
_state.storeFunctor(monitor); _state.storeFunctor(monitor);
checkpoint->add(*monitor); checkpoint->add(*monitor);
monitor->add(*generationCounter); monitor->add(*generationCounter);

4
eo/src/eoCombinedContinue.h
View file

@ -57,6 +57,7 @@ public:
{ {
} }
/* FIXME remove in next release
/// Ctor - for historical reasons ... should disspear some day /// Ctor - for historical reasons ... should disspear some day
eoCombinedContinue( eoContinue<EOT>& _cont1, eoContinue<EOT>& _cont2) eoCombinedContinue( eoContinue<EOT>& _cont1, eoContinue<EOT>& _cont2)
: eoContinue<EOT>(), std::vector<eoContinue<EOT>* >() : eoContinue<EOT>(), std::vector<eoContinue<EOT>* >()
@ -68,12 +69,14 @@ public:
this->push_back(&_cont1); this->push_back(&_cont1);
this->push_back(&_cont2); this->push_back(&_cont2);
} }
*/
void add(eoContinue<EOT> & _cont) void add(eoContinue<EOT> & _cont)
{ {
this->push_back(&_cont); this->push_back(&_cont);
} }
/* FIXME remove in next release
void removeLast(void) void removeLast(void)
{ {
#ifndef DEPRECATED_MESSAGES #ifndef DEPRECATED_MESSAGES
@ -82,6 +85,7 @@ public:
this->pop_back(); this->pop_back();
} }
*/
/** Returns false when one of the embedded continuators say so (logical and) /** Returns false when one of the embedded continuators say so (logical and)

2
eo/src/eoCombinedInit.h
View file

@ -44,11 +44,13 @@ public:
rates.push_back(_rate); rates.push_back(_rate);
} }
/* FIXME remove in next release
void add(eoInit<EOT> & _init, double _rate, bool _verbose) void add(eoInit<EOT> & _init, double _rate, bool _verbose)
{ {
eo::log << eo::warnings << "WARNING: the use of the verbose parameter in eoCombinedInit::add is deprecated and will be removed in the next release." << std::endl; eo::log << eo::warnings << "WARNING: the use of the verbose parameter in eoCombinedInit::add is deprecated and will be removed in the next release." << std::endl;
add( _init, _rate ); add( _init, _rate );
} }
*/
/** The usual method to add objects to the combination /** The usual method to add objects to the combination
*/ */

2
eo/src/eoCtrlCContinue.h
View file

@ -30,7 +30,7 @@
#ifndef eoCtrlCContinue_h #ifndef eoCtrlCContinue_h
#define eoCtrlCContinue_h #define eoCtrlCContinue_h
#include <signal.h> #include <csignal>
#include <eoContinue.h> #include <eoContinue.h>
/** /**

11
eo/src/eoFunctorStore.h
View file

@ -28,6 +28,9 @@
#define _eoFunctorStore_h #define _eoFunctorStore_h
#include <vector> #include <vector>
#include<algorithm>
#include "utils/eoLogger.h"
class eoFunctorBase; class eoFunctorBase;
@ -52,6 +55,13 @@ public:
template <class Functor> template <class Functor>
Functor& storeFunctor(Functor* r) Functor& storeFunctor(Functor* r)
{ {
#ifndef NDEBUG
unsigned int existing = std::count( vec.begin(), vec.end(), r );
if( existing > 0 ) {
eo::log << eo::warnings << "WARNING: you asked eoFunctorStore to store the functor " << r << " "
<< existing + 1 << " times, a segmentation fault may occur in the destructor." << std::endl;
}
#endif
// If the compiler complains about the following line, // If the compiler complains about the following line,
// check if you really are giving it a pointer to an // check if you really are giving it a pointer to an
// eoFunctorBase derived object // eoFunctorBase derived object
@ -67,6 +77,7 @@ private :
/** no assignment allowed */ /** no assignment allowed */
eoFunctorStore operator=(const eoFunctorStore&); eoFunctorStore operator=(const eoFunctorStore&);
protected:
std::vector<eoFunctorBase*> vec; std::vector<eoFunctorBase*> vec;
}; };

10
eo/src/eoMergeReduce.h
View file

@ -55,7 +55,7 @@ class eoMergeReduce : public eoReplacement<EOT>
merge(_merge), reduce(_reduce) merge(_merge), reduce(_reduce)
{} {}
void operator()(eoPop<EOT>& _parents, eoPop<EOT>& _offspring) virtual void operator()(eoPop<EOT>& _parents, eoPop<EOT>& _offspring)
{ {
merge(_parents, _offspring); // parents untouched, result in offspring merge(_parents, _offspring); // parents untouched, result in offspring
reduce(_offspring, _parents.size()); reduce(_offspring, _parents.size());
@ -92,6 +92,14 @@ class eoCommaReplacement : public eoMergeReduce<EOT>
public : public :
eoCommaReplacement() : eoMergeReduce<EOT>(no_elite, truncate) {} eoCommaReplacement() : eoMergeReduce<EOT>(no_elite, truncate) {}
virtual void operator()(eoPop<EOT>& _parents, eoPop<EOT>& _offspring)
{
// There must be more offsprings than parents, or else an exception will be raised
assert( _offspring.size() >= _parents.size() );
eoMergeReduce<EOT>::operator()( _parents, _offspring );
}
private : private :
eoNoElitism<EOT> no_elite; eoNoElitism<EOT> no_elite;
eoTruncate<EOT> truncate; eoTruncate<EOT> truncate;

482
eo/src/eoPop.h
View file

@ -4,31 +4,41 @@
// eoPop.h // eoPop.h
// (c) GeNeura Team, 1998 // (c) GeNeura Team, 1998
/* /*
This library is free software; you can redistribute it and/or This library is free software; you can redistribute it and/or
modify it under the terms of the GNU Lesser General Public modify it under the terms of the GNU Lesser General Public
License as published by the Free Software Foundation; either License as published by the Free Software Foundation; either
version 2 of the License, or (at your option) any later version. version 2 of the License, or (at your option) any later version.
This library is distributed in the hope that it will be useful, This library is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
Lesser General Public License for more details. Lesser General Public License for more details.
You should have received a copy of the GNU Lesser General Public You should have received a copy of the GNU Lesser General Public
License along with this library; if not, write to the Free Software License along with this library; if not, write to the Free Software
Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
Contact: todos@geneura.ugr.es, http://geneura.ugr.es Authors:
*/ todos@geneura.ugr.es, http://geneura.ugr.es
jmerelo
gustavoromero
mac
maartenkeijzer
kuepper
okoenig
evomarc
Johann Dréo <johann.dreo@thalesgroup.com>
*/
//----------------------------------------------------------------------------- //-----------------------------------------------------------------------------
#ifndef _EOPOP_H #ifndef _EOPOP_H_
#define _EOPOP_H #define _EOPOP_H_
#include <algorithm> #include <algorithm>
#include <iostream> #include <iostream>
#include <iterator> // needed for GCC 3.2 #include <iterator> // needed for GCC 3.2
#include <vector> #include <vector>
#include <assert.h>
// EO includes // EO includes
#include <eoOp.h> // for eoInit #include <eoOp.h> // for eoInit
@ -54,18 +64,18 @@
template<class EOT> template<class EOT>
class eoPop: public std::vector<EOT>, public eoObject, public eoPersistent class eoPop: public std::vector<EOT>, public eoObject, public eoPersistent
{ {
public: public:
using std::vector<EOT>::size; using std::vector<EOT>::size;
using std::vector<EOT>::resize; using std::vector<EOT>::resize;
using std::vector<EOT>::operator[]; using std::vector<EOT>::operator[];
using std::vector<EOT>::begin; using std::vector<EOT>::begin;
using std::vector<EOT>::end; using std::vector<EOT>::end;
typedef typename EOT::Fitness Fitness; typedef typename EOT::Fitness Fitness;
#if defined(__CUDACC__) #if defined(__CUDACC__)
typedef typename std::vector<EOT>::iterator iterator; typedef typename std::vector<EOT>::iterator iterator;
typedef typename std::vector<EOT>::const_iterator const_iterator; typedef typename std::vector<EOT>::const_iterator const_iterator;
#endif #endif
/** Default ctor. Creates empty pop /** Default ctor. Creates empty pop
@ -74,266 +84,296 @@ public:
/** Ctor for the initialization of chromosomes /** Ctor for the initialization of chromosomes
@param _popSize total population size @param _popSize total population size
@param _chromInit Initialization routine, produces EO's, needs to be an eoInit @param _chromInit Initialization routine, produces EO's, needs to be an eoInit
*/ */
eoPop( unsigned _popSize, eoInit<EOT>& _chromInit ) eoPop( unsigned _popSize, eoInit<EOT>& _chromInit )
:std::vector<EOT>() : std::vector<EOT>()
{ {
resize(_popSize); resize(_popSize);
for ( unsigned i = 0; i < _popSize; i++ ) for ( unsigned i = 0; i < _popSize; i++ )
{ {
_chromInit(operator[](i)); _chromInit(operator[](i));
} }
}; }
/** appends random guys at end of pop. /** appends random guys at end of pop.
Can be used to initialize it pop is empty Can be used to initialize it pop is empty
@param _newPopSize total population size @param _newPopSize total population size
@param _chromInit Initialization routine, produces EO's, needs to be an eoInit @param _chromInit Initialization routine, produces EO's, needs to be an eoInit
*/ */
void append( unsigned _newPopSize, eoInit<EOT>& _chromInit ) void append( unsigned _newPopSize, eoInit<EOT>& _chromInit )
{
unsigned oldSize = size();
if (_newPopSize < oldSize)
{ {
throw std::runtime_error("New size smaller than old size in pop.append"); unsigned oldSize = size();
return; if (_newPopSize < oldSize)
{
throw std::runtime_error("New size smaller than old size in pop.append");
return;
}
if (_newPopSize == oldSize)
return;
resize(_newPopSize); // adjust the size
for ( unsigned i = oldSize; i < _newPopSize; i++ )
{
_chromInit(operator[](i));
}
} }
if (_newPopSize == oldSize)
return;
resize(_newPopSize); // adjust the size /** Ctor from an std::istream; reads the population from a stream,
for ( unsigned i = oldSize; i < _newPopSize; i++ ) each element should be in different lines
@param _is the stream
*/
eoPop( std::istream& _is ) :std::vector<EOT>()
{ {
_chromInit(operator[](i)); readFrom( _is );
} }
};
/** Ctor from an std::istream; reads the population from a stream, /** Empty Dtor */
each element should be in different lines
@param _is the stream
*/
eoPop( std::istream& _is ) :std::vector<EOT>() {
readFrom( _is );
}
/** Empty Dtor */
virtual ~eoPop() {} virtual ~eoPop() {}
/// helper struct for getting a pointer /// helper struct for getting a pointer
struct Ref { const EOT* operator()(const EOT& eot) { return &eot;}}; struct Ref { const EOT* operator()(const EOT& eot) { return &eot;}};
/// helper struct for comparing on pointers
struct Cmp { /// helper struct for comparing on pointers
bool operator()(const EOT* a, const EOT* b) const struct Cmp {
bool operator()(const EOT* a, const EOT* b) const
{ return b->operator<(*a); } { return b->operator<(*a); }
}; };
/// helper struct for comparing (EA or PSO)
struct Cmp2 /// helper struct for comparing (EA or PSO)
{ struct Cmp2
bool operator()(const EOT & a,const EOT & b) const
{ {
bool operator()(const EOT & a,const EOT & b) const
{
return b.operator<(a); return b.operator<(a);
}
};
/**
sort the population. Use this member to sort in order
of descending Fitness, so the first individual is the best!
*/
void sort(void)
{
std::sort(begin(), end(), Cmp2());
} }
};
/** creates a std::vector<EOT*> pointing to the individuals in descending order */
void sort(std::vector<const EOT*>& result) const
{
result.resize(size());
/** std::transform(begin(), end(), result.begin(), Ref());
sort the population. Use this member to sort in order
of descending Fitness, so the first individual is the best!
*/
void sort(void)
{
std::sort(begin(), end(), Cmp2());
}
/** creates a std::vector<EOT*> pointing to the individuals in descending order */ std::sort(result.begin(), result.end(), Cmp());
void sort(std::vector<const EOT*>& result) const }
{
result.resize(size());
std::transform(begin(), end(), result.begin(), Ref());
std::sort(result.begin(), result.end(), Cmp()); /**
} shuffle the population. Use this member to put the population
in random order
*/
void shuffle(void)
{
UF_random_generator<unsigned int> gen;
std::random_shuffle(begin(), end(), gen);
}
/**
shuffle the population. Use this member to put the population
in random order
*/
void shuffle(void)
{
UF_random_generator<unsigned int> gen;
std::random_shuffle(begin(), end(), gen);
}
/** creates a std::vector<EOT*> pointing to the individuals in random order */ /** creates a std::vector<EOT*> pointing to the individuals in random order */
void shuffle(std::vector<const EOT*>& result) const void shuffle(std::vector<const EOT*>& result) const
{ {
result.resize(size()); result.resize(size());
std::transform(begin(), end(), result.begin(), Ref()); std::transform(begin(), end(), result.begin(), Ref());
UF_random_generator<unsigned int> gen; UF_random_generator<unsigned int> gen;
std::random_shuffle(result.begin(), result.end(), gen); std::random_shuffle(result.begin(), result.end(), gen);
} }
/** returns an iterator to the best individual DOES NOT MOVE ANYBODY */
/** returns an iterator to the best individual DOES NOT MOVE ANYBODY */
#if defined(__CUDACC__) #if defined(__CUDACC__)
eoPop<EOT>::iterator it_best_element() eoPop<EOT>::iterator it_best_element()
{ {
eoPop<EOT>:: iterator it = std::max_element(begin(), end()); eoPop<EOT>:: iterator it = std::max_element(begin(), end());
#else #else
typename eoPop<EOT>::iterator it_best_element() { typename eoPop<EOT>::iterator it_best_element()
typename eoPop<EOT>::iterator it = std::max_element(begin(), end()); {
assert( this->size() > 0 );
typename eoPop<EOT>::iterator it = std::max_element(begin(), end());
#endif #endif
return it; return it;
} }
/** returns an iterator to the best individual DOES NOT MOVE ANYBODY */
const EOT & best_element() const /** returns an iterator to the best individual DOES NOT MOVE ANYBODY */
{ const EOT & best_element() const
{
#if defined(__CUDACC__) #if defined(__CUDACC__)
eoPop<EOT>::const_iterator it = std::max_element(begin(), end()); eoPop<EOT>::const_iterator it = std::max_element(begin(), end());
#else #else
typename eoPop<EOT>::const_iterator it = std::max_element(begin(), end()); typename eoPop<EOT>::const_iterator it = std::max_element(begin(), end());
#endif #endif
return (*it); return (*it);
} }
/** returns a const reference to the worse individual DOES NOT MOVE ANYBODY */
const EOT & worse_element() const /** returns a const reference to the worse individual DOES NOT MOVE ANYBODY */
{ const EOT & worse_element() const
{
#if defined(__CUDACC__) #if defined(__CUDACC__)
eoPop<EOT>::const_iterator it = std::min_element(begin(), end()); eoPop<EOT>::const_iterator it = std::min_element(begin(), end());
#else #else
typename eoPop<EOT>::const_iterator it = std::min_element(begin(), end()); assert( this->size() > 0 );
typename eoPop<EOT>::const_iterator it = std::min_element(begin(), end());
#endif #endif
return (*it); return (*it);
} }
/** returns an iterator to the worse individual DOES NOT MOVE ANYBODY */
/** returns an iterator to the worse individual DOES NOT MOVE ANYBODY */
#if defined(__CUDACC__) #if defined(__CUDACC__)
eoPop<EOT>::iterator it_worse_element() eoPop<EOT>::iterator it_worse_element()
{ {
eoPop<EOT>::iterator it = std::min_element(begin(), end()); eoPop<EOT>::iterator it = std::min_element(begin(), end());
#else #else
typename eoPop<EOT>::iterator it_worse_element() typename eoPop<EOT>::iterator it_worse_element()
{ {
typename eoPop<EOT>::iterator it = std::min_element(begin(), end()); assert( this->size() > 0 );
typename eoPop<EOT>::iterator it = std::min_element(begin(), end());
#endif #endif
return it; return it;
} }
/**
slightly faster algorithm than sort to find all individuals that are better /**
than the nth individual. INDIVIDUALS ARE MOVED AROUND in the pop. slightly faster algorithm than sort to find all individuals that are better
*/ than the nth individual. INDIVIDUALS ARE MOVED AROUND in the pop.
*/
#if defined(__CUDACC__) #if defined(__CUDACC__)
eoPop<EOT>::iterator nth_element(int nth) eoPop<EOT>::iterator nth_element(int nth)
{ {
eoPop<EOT>::iterator it = begin() + nth; eoPop<EOT>::iterator it = begin() + nth;
#else #else
typename eoPop<EOT>::iterator nth_element(int nth) typename eoPop<EOT>::iterator nth_element(int nth)
{ {
typename eoPop<EOT>::iterator it = begin() + nth; assert( this->size() > 0 );
typename eoPop<EOT>::iterator it = begin() + nth;
#endif #endif
std::nth_element(begin(), it, end(), std::greater<EOT>()); std::nth_element(begin(), it, end(), std::greater<EOT>());
return it; return it;
} }
struct GetFitness { Fitness operator()(const EOT& _eo) const { return _eo.fitness(); } };
/** returns the fitness of the nth element */ struct GetFitness { Fitness operator()(const EOT& _eo) const { return _eo.fitness(); } };
Fitness nth_element_fitness(int which) const
{ // probably not the fastest way to do this, but what the heck
std::vector<Fitness> fitness(size());
std::transform(begin(), end(), fitness.begin(), GetFitness());
typename std::vector<Fitness>::iterator it = fitness.begin() + which; /** returns the fitness of the nth element */
std::nth_element(fitness.begin(), it, fitness.end(), std::greater<Fitness>()); Fitness nth_element_fitness(int which) const
return *it; { // probably not the fastest way to do this, but what the heck
}
/** const nth_element function, returns pointers to sorted individuals std::vector<Fitness> fitness(size());
* up the the nth std::transform(begin(), end(), fitness.begin(), GetFitness());
*/
void nth_element(int which, std::vector<const EOT*>& result) const
{
result.resize(size()); typename std::vector<Fitness>::iterator it = fitness.begin() + which;
std::transform(begin(), end(), result.begin(), Ref()); std::nth_element(fitness.begin(), it, fitness.end(), std::greater<Fitness>());
return *it;
}
typename std::vector<const EOT*>::iterator it = result.begin() + which;
std::nth_element(result.begin(), it, result.end(), Cmp()); /** const nth_element function, returns pointers to sorted individuals
} * up the the nth
*/
void nth_element(int which, std::vector<const EOT*>& result) const
{
/** does STL swap with other pop */ assert( this->size() > 0 );
void swap(eoPop<EOT>& other) result.resize(size());
{ std::transform(begin(), end(), result.begin(), Ref());
std::swap(static_cast<std::vector<EOT>& >(*this), static_cast<std::vector<EOT>& >(other));
}
/** typename std::vector<const EOT*>::iterator it = result.begin() + which;
* Prints sorted pop but does NOT modify it!
*
* @param _os A std::ostream.
*/
virtual void sortedPrintOn(std::ostream& _os) const
{
std::vector<const EOT*> result;
sort(result);
_os << size() << '\n';
for (unsigned i = 0; i < size(); ++i)
{
_os << *result[i] << std::endl;
}
}
/** std::nth_element(result.begin(), it, result.end(), Cmp());
* Write object. It's called printOn since it prints the object _on_ a stream. }
* @param _os A std::ostream.
*/
virtual void printOn(std::ostream& _os) const
{
_os << size() << '\n';
std::copy( begin(), end(), std::ostream_iterator<EOT>( _os, "\n") );
}
/** @name Methods from eoObject */
//@{
/**
* Read object. The EOT class must have a ctor from a stream;
* @param _is A std::istream.
*/
virtual void readFrom(std::istream& _is)
{
size_t sz;
_is >> sz;
resize(sz); /** does STL swap with other pop */
void swap(eoPop<EOT>& other)
{
std::swap(static_cast<std::vector<EOT>& >(*this), static_cast<std::vector<EOT>& >(other));
}
for (size_t i = 0; i < sz; ++i) {
operator[](i).readFrom( _is );
}
}
/** Inherited from eoObject. Returns the class name. /**
@see eoObject * Prints sorted pop but does NOT modify it!
*/ *
virtual std::string className() const {return "eoPop";}; * @param _os A std::ostream.
//@} */
virtual void sortedPrintOn(std::ostream& _os) const
{
std::vector<const EOT*> result;
sort(result);
_os << size() << '\n';
for (unsigned i = 0; i < size(); ++i)
{
_os << *result[i] << std::endl;
}
}
virtual void invalidate()
{
for (unsigned i=0; i<size(); i++)
this->operator[](i).invalidate();
}
};
#endif /**
* Write object. It's called printOn since it prints the object _on_ a stream.
* @param _os A std::ostream.
*/
virtual void printOn(std::ostream& _os) const
{
_os << size() << '\n';
std::copy( begin(), end(), std::ostream_iterator<EOT>( _os, "\n") );
}
/** @name Methods from eoObject */
//@{
/**
* Read object. The EOT class must have a ctor from a stream;
* @param _is A std::istream.
*/
virtual void readFrom(std::istream& _is)
{
size_t sz;
_is >> sz;
resize(sz);
for (size_t i = 0; i < sz; ++i) {
operator[](i).readFrom( _is );
}
}
/** Inherited from eoObject. Returns the class name.
@see eoObject
*/
virtual std::string className() const {return "eoPop";};
//@}
/** Invalidate the whole population
*/
virtual void invalidate()
{
for (unsigned i=0; i<size(); i++)
this->operator[](i).invalidate();
}
}; // class eoPop
#endif // _EOPOP_H_

4
eo/src/eoProportionalCombinedOp.h
View file

@ -186,6 +186,7 @@ public:
virtual std::string className() const { return "eoPropCombinedQuadOp"; } virtual std::string className() const { return "eoPropCombinedQuadOp"; }
/* FIXME remove in next release
virtual void add(eoQuadOp<EOT> & _op, const double _rate, bool _verbose) virtual void add(eoQuadOp<EOT> & _op, const double _rate, bool _verbose)
{ {
#ifndef DEPRECATED_MESSAGES #ifndef DEPRECATED_MESSAGES
@ -195,6 +196,7 @@ public:
add(_op,_rate); add(_op,_rate);
} }
*/
// addition of a true operator // addition of a true operator
virtual void add(eoQuadOp<EOT> & _op, const double _rate) virtual void add(eoQuadOp<EOT> & _op, const double _rate)
@ -202,7 +204,7 @@ public:
ops.push_back(&_op); ops.push_back(&_op);
rates.push_back(_rate); rates.push_back(_rate);
// compute the relative rates in percent - to warn the user! // compute the relative rates in percent - to warn the user!
printOn( eo::log << eo::logging ); printOn( eo::log << eo::logging );
} }
// outputs the operators and percentages // outputs the operators and percentages

2
eo/src/eoScalarFitnessAssembled.h
View file

@ -212,7 +212,7 @@ public:
//! Print term values and descriptions //! Print term values and descriptions
void printAll(std::ostream& os) const { void printAll(std::ostream& os) const {
for (size_type i=0; i < size(); ++i ) for (size_type i=0; i < size(); ++i )
os << FitnessTraits::getDescription(i) << " = " << operator[](i) << " "; os << FitnessTraits::getDescription(i) << " = " << this->operator[](i) << " ";
} }
//! Comparison, using less by default //! Comparison, using less by default

2
eo/src/ga/make_continue_ga.cpp
View file

@ -37,7 +37,7 @@
* *
* The corresponding ***INSTANCIATED DECLARATIONS*** are contained * The corresponding ***INSTANCIATED DECLARATIONS*** are contained
* in ga.h * in ga.h
* while the TEMPLATIZED code is define in make_contninue.h in the src/do dir * while the TEMPLATIZED code is define in make_continue.h in the src/do dir
* *
* Unlike most EO .h files, it does not (and should not) contain any code, * Unlike most EO .h files, it does not (and should not) contain any code,
* just declarations * just declarations

4
eo/src/ga/make_ga.h
View file

@ -57,8 +57,8 @@
*/ */
// the genotypes // the genotypes
eoInit<eoBit<double> > & make_genotype(eoParser& _parser, eoState& _state, eoBit<double> _eo); eoInit<eoBit<double> > & make_genotype(eoParser& _parser, eoState& _state, eoBit<double> _eo, float _bias=0.5);
eoInit<eoBit<eoMinimizingFitness> > & make_genotype(eoParser& _parser, eoState& _state, eoBit<eoMinimizingFitness> _eo); eoInit<eoBit<eoMinimizingFitness> > & make_genotype(eoParser& _parser, eoState& _state, eoBit<eoMinimizingFitness> _eo, float _bias=0.5);
// the operators // the operators
eoGenOp<eoBit<double> >& make_op(eoParser& _parser, eoState& _state, eoInit<eoBit<double> >& _init); eoGenOp<eoBit<double> >& make_op(eoParser& _parser, eoState& _state, eoInit<eoBit<double> >& _init);

8
eo/src/ga/make_genotype_ga.cpp
View file

@ -45,11 +45,11 @@
/// The following function merely call the templatized do_* functions above /// The following function merely call the templatized do_* functions above
eoInit<eoBit<double> > & make_genotype(eoParser& _parser, eoState& _state, eoBit<double> _eo) eoInit<eoBit<double> > & make_genotype(eoParser& _parser, eoState& _state, eoBit<double> _eo, float _bias)
{ {
return do_make_genotype(_parser, _state, _eo); return do_make_genotype(_parser, _state, _eo, _bias);
} }
eoInit<eoBit<eoMinimizingFitness> > & make_genotype(eoParser& _parser, eoState& _state, eoBit<eoMinimizingFitness> _eo) eoInit<eoBit<eoMinimizingFitness> > & make_genotype(eoParser& _parser, eoState& _state, eoBit<eoMinimizingFitness> _eo, float _bias)
{ {
return do_make_genotype(_parser, _state, _eo); return do_make_genotype(_parser, _state, _eo, _bias);
} }

4
eo/src/ga/make_genotype_ga.h
View file

@ -60,7 +60,7 @@
* @ingroup Builders * @ingroup Builders
*/ */
template <class EOT> template <class EOT>
eoInit<EOT> & do_make_genotype(eoParser& _parser, eoState& _state, EOT) eoInit<EOT> & do_make_genotype(eoParser& _parser, eoState& _state, EOT, float _bias=0.5)
{ {
// for bitstring, only thing needed is the size // for bitstring, only thing needed is the size
// but it might have been already read in the definition fo the performance // but it might have been already read in the definition fo the performance
@ -68,7 +68,7 @@ eoInit<EOT> & do_make_genotype(eoParser& _parser, eoState& _state, EOT)
// Then we can built a bitstring random initializer // Then we can built a bitstring random initializer
// based on boolean_generator class (see utils/rnd_generator.h) // based on boolean_generator class (see utils/rnd_generator.h)
eoBooleanGenerator * gen = new eoBooleanGenerator; eoBooleanGenerator * gen = new eoBooleanGenerator(_bias);
_state.storeFunctor(gen); _state.storeFunctor(gen);
eoInitFixedLength<EOT>* init = new eoInitFixedLength<EOT>(theSize, *gen); eoInitFixedLength<EOT>* init = new eoInitFixedLength<EOT>(theSize, *gen);
// store in state // store in state

17
eo/src/ga/make_op.h
View file

@ -156,11 +156,23 @@ eoGenOp<EOT> & do_make_op(eoParser& _parser, eoState& _state, eoInit<EOT>& _init
if ( (bitFlipRateParam.value() < 0) ) if ( (bitFlipRateParam.value() < 0) )
throw std::runtime_error("Invalid bitFlipRate"); throw std::runtime_error("Invalid bitFlipRate");
// oneBitFlip
eoValueParam<double> & oneBitRateParam = _parser.createParam(0.01, "oneBitRate", "Relative rate for deterministic bit-flip mutation", 'd', "Variation Operators" ); eoValueParam<double> & oneBitRateParam = _parser.createParam(0.01, "oneBitRate", "Relative rate for deterministic bit-flip mutation", 'd', "Variation Operators" );
// minimum check // minimum check
if ( (oneBitRateParam.value() < 0) ) if ( (oneBitRateParam.value() < 0) )
throw std::runtime_error("Invalid oneBitRate"); throw std::runtime_error("Invalid oneBitRate");
// kBitFlip
eoValueParam<unsigned> & kBitParam = _parser.createParam((unsigned)1, "kBit", "Number of bit for deterministic k bit-flip mutation", 0, "Variation Operators" );
// minimum check
if ( ! kBitParam.value() )
throw std::runtime_error("Invalid kBit");
eoValueParam<double> & kBitRateParam = _parser.createParam(0.0, "kBitRate", "Relative rate for deterministic k bit-flip mutation", 0, "Variation Operators" );
// minimum check
if ( (kBitRateParam.value() < 0) )
throw std::runtime_error("Invalid kBitRate");
// minimum check // minimum check
// bool bMut = true; // not used ? // bool bMut = true; // not used ?
if (bitFlipRateParam.value()+oneBitRateParam.value()==0) if (bitFlipRateParam.value()+oneBitRateParam.value()==0)
@ -184,6 +196,11 @@ eoGenOp<EOT> & do_make_op(eoParser& _parser, eoState& _state, eoInit<EOT>& _init
_state.storeFunctor(ptMon); _state.storeFunctor(ptMon);
ptCombinedMonOp->add(*ptMon, oneBitRateParam.value()); ptCombinedMonOp->add(*ptMon, oneBitRateParam.value());
// mutate exactly k bit per individual
ptMon = new eoDetBitFlip<EOT>(kBitParam.value());
_state.storeFunctor(ptMon);
ptCombinedMonOp->add(*ptMon, kBitRateParam.value());
_state.storeFunctor(ptCombinedMonOp); _state.storeFunctor(ptCombinedMonOp);
// now build the eoGenOp: // now build the eoGenOp:

4
eo/src/gp/eoParseTree.h
View file

@ -94,7 +94,7 @@ public:
while (size() > _size) while (size() > _size)
{ {
back() = operator[](size()-2); back() = this->operator[](size()-2);
} }
} }
@ -150,7 +150,7 @@ public:
v[i] = node; v[i] = node;
} }
parse_tree<Node> tmp(v.begin(), v.end()); parse_tree<Node> tmp(v.begin(), v.end());
swap(tmp); this->swap(tmp);
/* /*
* old code which caused problems for paradisEO * old code which caused problems for paradisEO

1
eo/src/utils/CMakeLists.txt
View file

@ -29,6 +29,7 @@ SET(EOUTILS_SOURCES
pipecom.cpp pipecom.cpp
eoLogger.cpp eoLogger.cpp
eoParallel.cpp eoParallel.cpp
eoSignal.cpp
) )
ADD_LIBRARY(eoutils STATIC ${EOUTILS_SOURCES}) ADD_LIBRARY(eoutils STATIC ${EOUTILS_SOURCES})

1
eo/src/utils/checkpointing
View file

@ -36,6 +36,7 @@
#include <utils/eoGnuplot1DSnapshot.h> #include <utils/eoGnuplot1DSnapshot.h>
#endif #endif
#include <utils/eoCheckPoint.h> #include <utils/eoCheckPoint.h>
#include <utils/eoSignal.h>
#include <utils/eoStat.h> #include <utils/eoStat.h>
#include <utils/eoScalarFitnessStat.h> #include <utils/eoScalarFitnessStat.h>
#include <utils/eoAssembledFitnessStat.h> #include <utils/eoAssembledFitnessStat.h>

1
eo/src/utils/eoOStreamMonitor.cpp
View file

@ -37,6 +37,7 @@ eoMonitor& eoOStreamMonitor::operator()(void)
} // if firstime } // if firstime
// ok, now the real saving. write out // ok, now the real saving. write out
// FIXME deprecated, remove in next release
//! @todo old verbose formatting, do we still need it? //! @todo old verbose formatting, do we still need it?
/* /*
for (iterator it = vec.begin (); it != vec.end (); ++it) { for (iterator it = vec.begin (); it != vec.end (); ++it) {

5
eo/src/utils/eoOStreamMonitor.h
View file

@ -44,14 +44,17 @@ Authors:
class eoOStreamMonitor : public eoMonitor class eoOStreamMonitor : public eoMonitor
{ {
public : public :
eoOStreamMonitor( std::ostream & _out, bool /*_verbose*/=true, std::string _delim = "\t", unsigned int _width=20, char _fill=' ' ) : /* FIXME remove in next release
eoOStreamMonitor( std::ostream & _out, bool _verbose=true, std::string _delim = "\t", unsigned int _width=20, char _fill=' ' ) :
out(_out), delim(_delim), width(_width), fill(_fill), firsttime(true) out(_out), delim(_delim), width(_width), fill(_fill), firsttime(true)
{ {
#ifndef DEPRECATED_MESSAGES #ifndef DEPRECATED_MESSAGES
eo::log << eo::warnings << "WARNING: the use of the verbose parameter in eoOStreamMonitor constructor is deprecated and will be removed in the next release" << std::endl; eo::log << eo::warnings << "WARNING: the use of the verbose parameter in eoOStreamMonitor constructor is deprecated and will be removed in the next release" << std::endl;
#pragma message "WARNING: the use of the verbose parameter in eoOStreamMonitor constructor is deprecated and will be removed in the next release" #pragma message "WARNING: the use of the verbose parameter in eoOStreamMonitor constructor is deprecated and will be removed in the next release"
#endif // !DEPRECATED_MESSAGES #endif // !DEPRECATED_MESSAGES
} }
*/
eoOStreamMonitor( std::ostream & _out, std::string _delim = "\t", unsigned int _width=20, char _fill=' ' ) : eoOStreamMonitor( std::ostream & _out, std::string _delim = "\t", unsigned int _width=20, char _fill=' ' ) :
out(_out), delim(_delim), width(_width), fill(_fill), firsttime(true) out(_out), delim(_delim), width(_width), fill(_fill), firsttime(true)

2
eo/src/utils/eoParallel.cpp
View file

@ -25,7 +25,9 @@ Caner Candan <caner.candan@thalesgroup.com>
*/ */
#ifdef _OPENMP
#include <omp.h> #include <omp.h>
#endif
#include "eoParallel.h" #include "eoParallel.h"
#include "eoLogger.h" #include "eoLogger.h"

36
eo/src/utils/eoParserLogger.h
View file

@ -1,36 +0,0 @@
// -*- mode: c++; c-indent-level: 4; c++-member-init-indent: 8; comment-column: 35; -*-
/*
(c) Thales group, 2010
This library is free software; you can redistribute it and/or
modify it under the terms of the GNU Lesser General Public
License as published by the Free Software Foundation;
version 2 of the License.
This library is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
Lesser General Public License for more details.
You should have received a copy of the GNU Lesser General Public
License along with this library; if not, write to the Free Software
Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
Contact: http://eodev.sourceforge.net
Authors:
Caner Candan <caner.candan@thalesgroup.com>
*/
#ifndef EO_PARSER_LOGGER_H
#define EO_PARSER_LOGGER_H
#include "eoParser.h"
#warning "[eoParserLogger] is deprecated"
typedef eoParser eoParserLogger;
#endif // !EO_PARSER_LOGGER_H

6
eo/src/utils/eoRNG.h
View file

@ -150,7 +150,8 @@ public :
initialize(2*s); initialize(2*s);
} }
/** Re-initializes the Random Number Generator /* FIXME remove in next release
** Re-initializes the Random Number Generator
This is the traditional seeding procedure. This version is deprecated and This is the traditional seeding procedure. This version is deprecated and
only provided for compatibility with old code. In new projects you should only provided for compatibility with old code. In new projects you should
@ -159,11 +160,12 @@ public :
@see reseed for details on usage of the seeding value. @see reseed for details on usage of the seeding value.
@version old version (deprecated) @version old version (deprecated)
*/ *
void oldReseed(uint32_t s) void oldReseed(uint32_t s)
{ {
initialize(s); initialize(s);
} }
*/
/** Random number from unifom distribution /** Random number from unifom distribution

36
eo/src/utils/eoSignal.cpp Normal file
View file

@ -0,0 +1,36 @@
// -*- mode: c++; c-indent-level: 4; c++-member-init-indent: 8; comment-column: 35; -*-
/**
This library is free software; you can redistribute it and/or
modify it under the terms of the GNU Lesser General Public
License as published by the Free Software Foundation; either
version 2 of the License, or (at your option) any later version.
This library is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
Lesser General Public License for more details.
You should have received a copy of the GNU Lesser General Public
License along with this library; if not, write to the Free Software
Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
Contact: http://eodev.sourceforge.net
Autors: todos@geneura.ugr.es, http://geneura.ugr.es
Marc.Schoenauer@polytechnique.fr
mak@dhi.dk
Caner.Candan@univ-angers.fr
*/
#include <utils/eoSignal.h>
/**
* @addtogroup Continuators
* @{
*/
// --- Global variables - but don't know what else to do - MS ---
std::map< int, bool > signals_called;
/** @} */

106
eo/src/utils/eoSignal.h Normal file
View file

@ -0,0 +1,106 @@
// -*- mode: c++; c-indent-level: 4; c++-member-init-indent: 8; comment-column: 35; -*-
/**
This library is free software; you can redistribute it and/or
modify it under the terms of the GNU Lesser General Public
License as published by the Free Software Foundation; either
version 2 of the License, or (at your option) any later version.
This library is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
Lesser General Public License for more details.
You should have received a copy of the GNU Lesser General Public
License along with this library; if not, write to the Free Software
Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
Contact: http://eodev.sourceforge.net
Authors: todos@geneura.ugr.es, http://geneura.ugr.es
Marc.Schoenauer@polytechnique.fr
mak@dhi.dk
Caner.Candan@univ-angers.fr
*/
#ifndef _eoSignal_h
#define _eoSignal_h
#include <csignal>
#include <utils/eoCheckPoint.h>
#include <utils/eoLogger.h>
#include <map>
#include <vector>
/**
* @addtogroup Continuators
* @{
*/
extern std::map< int, bool > signals_called;
/** eoSignal inherits from eoCheckPoint including signals handling (see signal(7))
*
* @ingroup Utilities
*/
template <class EOT>
class eoSignal : public eoCheckPoint<EOT>
{
public :
eoSignal( int sig = SIGINT ) : eoCheckPoint<EOT>( _dummyContinue ), _sig( sig )
{
::signals_called[_sig] = false;
#ifndef _WINDOWS
#ifdef SIGQUIT
::signal( _sig, handler );
#endif // !SIGQUIT
#endif // !_WINDOWS
}
eoSignal( eoContinue<EOT>& _cont, int sig = SIGINT ) : eoCheckPoint<EOT>( _cont ), _sig( sig )
{
::signals_called[_sig] = false;
#ifndef _WINDOWS
#ifdef SIGQUIT
::signal( _sig, handler );
#endif // !SIGQUIT
#endif // !_WINDOWS
}
bool operator()( const eoPop<EOT>& _pop )
{
bool& called = ::signals_called[_sig];
if ( called )
{
eo::log << eo::logging << "Signal granted…" << std::endl ;
called = false;
return this->eoCheckPoint<EOT>::operator()( _pop );
}
return true;
}
virtual std::string className(void) const { return "eoSignal"; }
static void handler( int sig )
{
::signals_called[sig] = true;
eo::log << eo::logging << "Signal wished…" << std::endl ;
}
private:
class DummyContinue : public eoContinue<EOT>
{
public:
bool operator() ( const eoPop<EOT>& ) { return true; }
} _dummyContinue;
int _sig;
};
/** @} */
#endif // !_eoSignal_h

62
eo/src/utils/eoState.cpp
View file

@ -18,7 +18,7 @@ using namespace std;
void removeComment(string& str, string comment) void eoState::removeComment(string& str, string comment)
{ {
string::size_type pos = str.find(comment); string::size_type pos = str.find(comment);
@ -28,21 +28,23 @@ void removeComment(string& str, string comment)
} }
} }
bool is_section(const string& str, string& name) bool eoState::is_section(const string& str, string& name)
{ {
string::size_type pos = str.find("\\section{"); string::size_type pos = str.find(_tag_section_so);
if (pos == string::npos) if (pos == string::npos)
return false; return false;
//else //else
string::size_type end = str.find("}"); string::size_type end = str.find(_tag_section_sc);
if (end == string::npos) if (end == string::npos)
return false; return false;
// else // else
name = str.substr(pos + 9, end-9); // affect name, passed by reference
// Note: substr( start, count )
name = str.substr( pos + _tag_section_so.size(), end - _tag_section_so.size() );
return true; return true;
} }
@ -84,6 +86,7 @@ void eoState::load(const string& _filename)
load(is); load(is);
} }
// FIXME implement parsing and loading of other formats
void eoState::load(std::istream& is) void eoState::load(std::istream& is)
{ {
string str; string str;
@ -158,16 +161,49 @@ void eoState::save(const string& filename) const
save(os); save(os);
} }
void eoState::save(std::ostream& os) const //void eoState::save(std::ostream& os) const
{ // saves in order of insertion //{ // saves in order of insertion
for (vector<ObjectMap::iterator>::const_iterator it = creationOrder.begin(); it != creationOrder.end(); ++it) // for (vector<ObjectMap::iterator>::const_iterator it = creationOrder.begin(); it != creationOrder.end(); ++it)
{ // {
os << "\\section{" << (*it)->first << "}\n"; // os << "\\section{" << (*it)->first << "}\n";
(*it)->second->printOn(os); // (*it)->second->printOn(os);
os << '\n'; // os << '\n';
} // }
//}
void eoState::saveSection( std::ostream& os, vector<ObjectMap::iterator>::const_iterator it) const
{
os << _tag_section_so << (*it)->first << _tag_section_sc;
os << _tag_content_s;
(*it)->second->printOn(os);
os << _tag_content_e;
os << _tag_section_e;
} }
void eoState::save(std::ostream& os) const
{
os << _tag_state_so << _tag_state_name << _tag_state_sc;
// save the first section
assert( creationOrder.size() > 0 );
// saves in order of insertion
vector<ObjectMap::iterator>::const_iterator it = creationOrder.begin();
saveSection(os,it);
it++;
while( it != creationOrder.end() ) {
// add a separator only before [1,n] elements
os << _tag_section_sep;
saveSection(os, it);
it++;
}
os << _tag_state_e;
}
string eoState::createObjectName(eoObject* obj) string eoState::createObjectName(eoObject* obj)
{ {
if (obj == 0) if (obj == 0)

80
eo/src/utils/eoState.h
View file

@ -31,6 +31,7 @@
#include <string> #include <string>
#include <map> #include <map>
#include <vector> #include <vector>
#include <assert.h>
#include <eoFunctorStore.h> #include <eoFunctorStore.h>
@ -56,10 +57,50 @@ class eoState : public eoFunctorStore
{ {
public : public :
eoState(void) {} eoState(std::string name="") :
_tag_state_so(""),
_tag_state_name(name),
_tag_state_sc(""),
_tag_section_so("\\section{"),
_tag_section_sc("}\n"),
_tag_content_s(""),
_tag_content_e(""),
_tag_section_sep(""),
_tag_section_e("\n"),
_tag_state_e("")
{}
~eoState(void); ~eoState(void);
void formatLatex(std::string name)
{
_tag_state_so = "";
_tag_state_name = name;
_tag_state_sc = "";
_tag_section_so = "\\section{";
_tag_section_sc = "}\n";
_tag_content_s = "";
_tag_content_e = "";
_tag_section_sep = "";
_tag_section_e = "\n";
_tag_state_e = "";
}
void formatJSON(std::string name)
{
_tag_state_so = "{ \"";
_tag_state_name = name;
_tag_state_sc = "\":\n";
_tag_section_so = "\t{ \"";
_tag_section_sc = "\":\n";
_tag_content_s = "\"";
_tag_content_e = "\"";
_tag_section_sep = ",\n";
_tag_section_e = "\t}\n";
_tag_state_e = "}\n";
}
/** /**
* Object registration function, note that it does not take ownership! * Object registration function, note that it does not take ownership!
*/ */
@ -131,6 +172,43 @@ private :
eoState(const eoState&); eoState(const eoState&);
eoState& operator=(const eoState&); eoState& operator=(const eoState&);
/* \@{
* s=start, e=end
* o=open, c=close
*
* { "my_state":
* {
* "section_pop":"…",
* "section_rng":"…"
* }
* }
*
* // JSON LATEX (default)
*/
std::string _tag_state_so; // { "
std::string _tag_state_name; // my_state
std::string _tag_state_sc; // ":
std::string _tag_section_so; // { " \\section{
std::string _tag_section_sc; // ": }\n
std::string _tag_content_s; // "
std::string _tag_content_e; // "
std::string _tag_section_sep;// ,
std::string _tag_section_e; // } \n
std::string _tag_state_e; // }
/** \@} */
void removeComment( std::string& str, std::string comment);
bool is_section(const std::string& str, std::string& name);
protected:
void saveSection( std::ostream& os, std::vector<ObjectMap::iterator>::const_iterator it) const;
}; };
/** @example t-eoStateAndParser.cpp /** @example t-eoStateAndParser.cpp
*/ */

6
eo/src/utils/eoStdoutMonitor.h
View file

@ -43,11 +43,15 @@ Authors:
class eoStdoutMonitor : public eoOStreamMonitor class eoStdoutMonitor : public eoOStreamMonitor
{ {
public : public :
/* FIXME remove in next release
eoStdoutMonitor(bool _verbose, std::string _delim = "\t", unsigned int _width=20, char _fill=' ' ) : eoStdoutMonitor(bool _verbose, std::string _delim = "\t", unsigned int _width=20, char _fill=' ' ) :
eoOStreamMonitor( std::cout, _verbose, _delim, _width, _fill) eoOStreamMonitor( std::cout, _verbose, _delim, _width, _fill)
{ {
eo::log << eo::warnings << "WARNING: the use of the verbose parameter in eoStdutMonitor constructor is deprecated and will be removed in the next release" << std::endl; #ifndef DEPRECATED_MESSAGES
eo::log << eo::warnings << "WARNING: the use of the verbose parameter in eoStdoutMonitor constructor is deprecated and will be removed in the next release" << std::endl;
#endif // !DEPRECATED_MESSAGES
} }
*/
eoStdoutMonitor(std::string _delim = "\t", unsigned int _width=20, char _fill=' ' ) : eoStdoutMonitor(std::string _delim = "\t", unsigned int _width=20, char _fill=' ' ) :
eoOStreamMonitor( std::cout, _delim, _width, _fill) eoOStreamMonitor( std::cout, _delim, _width, _fill)

2
eo/test/CMakeLists.txt
View file

@ -66,7 +66,7 @@ SET (TEST_LIST
t-eoLogger t-eoLogger
t-eoIQRStat t-eoIQRStat
t-eoParallel t-eoParallel
t-openmp #t-openmp # does not work anymore since functions used in this test were removed from EO
#t-eoDualFitness #t-eoDualFitness
t-eoParser t-eoParser
) )

3
eo/test/t-MGE-control.cpp
View file

@ -69,7 +69,8 @@ int main()
// Terminators // Terminators
eoGenContinue<Chrom> continuator1(10); eoGenContinue<Chrom> continuator1(10);
eoFitContinue<Chrom> continuator2(CHROM_SIZE); eoFitContinue<Chrom> continuator2(CHROM_SIZE);
eoCombinedContinue<Chrom> continuator(continuator1, continuator2); eoCombinedContinue<Chrom> continuator(continuator1);
continuator.add( continuator2 );
eoCheckPoint<Chrom> checkpoint(continuator); eoCheckPoint<Chrom> checkpoint(continuator);
eoStdoutMonitor monitor; eoStdoutMonitor monitor;
checkpoint.add(monitor); checkpoint.add(monitor);

3
eo/test/t-MGE.cpp
View file

@ -73,7 +73,8 @@ int main()
// Terminators // Terminators
eoGenContinue<Chrom> continuator1(10); eoGenContinue<Chrom> continuator1(10);
eoFitContinue<Chrom> continuator2(CHROM_SIZE); eoFitContinue<Chrom> continuator2(CHROM_SIZE);
eoCombinedContinue<Chrom> continuator(continuator1, continuator2); eoCombinedContinue<Chrom> continuator(continuator1);
continuator.add( continuator2);
eoCheckPoint<Chrom> checkpoint(continuator); eoCheckPoint<Chrom> checkpoint(continuator);
eoStdoutMonitor monitor; eoStdoutMonitor monitor;
checkpoint.add(monitor); checkpoint.add(monitor);

3
eo/test/t-MGE1bit.cpp
View file

@ -72,7 +72,8 @@ int main()
// Terminators // Terminators
eoGenContinue<Chrom> continuator1(10); eoGenContinue<Chrom> continuator1(10);
eoFitContinue<Chrom> continuator2(CHROM_SIZE); eoFitContinue<Chrom> continuator2(CHROM_SIZE);
eoCombinedContinue<Chrom> continuator(continuator1, continuator2); eoCombinedContinue<Chrom> continuator(continuator1);
continuator.add(continuator2);
eoCheckPoint<Chrom> checkpoint(continuator); eoCheckPoint<Chrom> checkpoint(continuator);
eoStdoutMonitor monitor; eoStdoutMonitor monitor;
checkpoint.add(monitor); checkpoint.add(monitor);

3
eo/test/t-eobin.cpp
View file

@ -139,7 +139,8 @@ void main_function()
eoGenContinue<Chrom> continuator1(50); eoGenContinue<Chrom> continuator1(50);
eoFitContinue<Chrom> continuator2(65535.f); eoFitContinue<Chrom> continuator2(65535.f);
eoCombinedContinue<Chrom> continuator(continuator1, continuator2); eoCombinedContinue<Chrom> continuator(continuator1);
continuator.add( continuator2);
eoCheckPoint<Chrom> checkpoint(continuator); eoCheckPoint<Chrom> checkpoint(continuator);

2
eo/test/t-openmp.cpp
View file

@ -39,6 +39,8 @@ Caner Candan <caner.candan@thalesgroup.com>
#include <omp.h> #include <omp.h>
#include <unistd.h>
#include "real_value.h" #include "real_value.h"
//----------------------------------------------------------------------------- //-----------------------------------------------------------------------------