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

Merge branch 'master' of ssh://eodev.git.sourceforge.net/gitroot/eodev/eodev

Browse source
This commit is contained in:
Caner Candan 2012-07-17 11:43:58 +02:00
commit bd243c9455
21 changed files with 891 additions and 342 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)
SET(PROJECT_VERSION_MAJOR 1)
SET(PROJECT_VERSION_MINOR 0)
SET(PROJECT_VERSION_MAJOR 0)
SET(PROJECT_VERSION_MINOR 1)
SET(PROJECT_VERSION_PATCH 0)
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
SET(CMAKE_MODULE_PATH ${CMAKE_SOURCE_DIR}/cmake/modules)
SET(CMAKE_MODULE_PATH ${PROJECT_SOURCE_DIR} ${CMAKE_SOURCE_DIR}/cmake/modules)
INCLUDE(FindDoxygen)
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)
INCLUDE_DIRECTORIES(
${EO_INCLUDE_DIRS}
${MO_INCLUDE_DIRS}
${Boost_INCLUDE_DIRS}
# /Dev/ometah-0.3/common
)
)
LINK_DIRECTORIES(
${EO_LIBRARY_DIRS}
)
)
######################################################################################
@ -58,7 +90,7 @@ LINK_DIRECTORIES(
INCLUDE_DIRECTORIES(
${CMAKE_CURRENT_SOURCE_DIR}/src
)
)
######################################################################################
@ -92,7 +124,7 @@ SET(SAMPLE_SRCS)
######################################################################################
ADD_SUBDIRECTORY(src)
#ADD_SUBDIRECTORY(application)
ADD_SUBDIRECTORY(application)
ADD_SUBDIRECTORY(test)
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
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

4
edo/application/CMakeLists.txt
View file

@ -7,8 +7,8 @@ INCLUDE_DIRECTORIES(
)
ADD_SUBDIRECTORY(common)
ADD_SUBDIRECTORY(eda_sa)
#ADD_SUBDIRECTORY(eda_sa)
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 <mo>
// #include <mo>
#include <eoEvalFuncCounterBounder.h>
@ -92,7 +92,7 @@ int main(int ac, char** av)
// 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
new edoBounderRng< EOT >( EOT(dimension_size, -5), EOT(dimension_size, 5), *gen); // FIXME do not use hard-coded bounds
state.storeFunctor(bounder);
// Prepare sampler class with a specific distribution
@ -117,7 +117,11 @@ int main(int ac, char** av)
// sample for sampling.
eoReplacement< EOT >* replacor = new eoEPReplacement< EOT >(pop.size());
state.storeFunctor(replacor);
// Help + Verbose routines
make_verbose(parser);
make_help(parser);
// Some stuff to display helper when we are using -h option
if (parser.userNeedsHelp())
{
@ -125,10 +129,6 @@ int main(int ac, char** av)
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
@ -162,9 +162,8 @@ int main(int ac, char** av)
// EDA algorithm configuration
edoAlgo< Distrib >* algo = new edoEDA< Distrib >
(*selector, *estimator, *sampler,
pop_continue, *distribution_continue,
popEval, *replacor);
(popEval, *selector, *estimator, *sampler, *replacor,
pop_continue, *distribution_continue );
// Beginning of the algorithm call
try {

2
edo/build_gcc_linux_debug
View file

@ -2,6 +2,6 @@
mkdir -p debug
cd debug
cmake -DCMAKE_BUILD_TYPE=Debug ..
cmake -DCMAKE_BUILD_TYPE=Debug -DWITH_BOOST=1 ..
make
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
#define _edoEstimatorNormalMulti_h
#include "edoEstimator.h"
#include "edoNormalMulti.h"
//! edoEstimatorNormalMulti< EOT >
#ifdef WITH_BOOST
//! edoEstimatorNormalMulti< EOT >
template < typename EOT >
class edoEstimatorNormalMulti : public edoEstimator< edoNormalMulti< EOT > >
{
@ -41,95 +43,95 @@ public:
class CovMatrix
{
public:
typedef typename EOT::AtomType AtomType;
typedef typename EOT::AtomType AtomType;
CovMatrix( const eoPop< EOT >& pop )
{
//-------------------------------------------------------------
// Some checks before starting to estimate covar
//-------------------------------------------------------------
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 p_size = pop.size(); // population size
assert(p_size > 0);
unsigned int s_size = pop[0].size(); // solution size
assert(s_size > 0);
unsigned int s_size = pop[0].size(); // solution size
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 j = 0; j < s_size; ++j)
{
sample(i, j) = pop[i][j];
}
}
for (unsigned int i = 0; i < p_size; ++i)
{
for (unsigned int j = 0; j < s_size; ++j)
{
sample(i, j) = pop[i][j];
}
}
//-------------------------------------------------------------
//-------------------------------------------------------------
_varcovar.resize(s_size);
_varcovar.resize(s_size);
//-------------------------------------------------------------
// variance-covariance matrix are symmetric (and semi-definite
// positive), thus a triangular storage is sufficient
//
// variance-covariance matrix computation : transpose(A) * A
//-------------------------------------------------------------
//-------------------------------------------------------------
// variance-covariance matrix are symmetric (and semi-definite
// positive), thus a triangular storage is sufficient
//
// 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.size2() == s_size);
assert(var.size1() == _varcovar.size1());
assert(var.size2() == _varcovar.size2());
assert(var.size1() == s_size);
assert(var.size2() == s_size);
assert(var.size1() == _varcovar.size1());
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)
// {
// // triangular LOWER matrix, thus j is not going further than i
// for (unsigned int j = 0; j <= i; ++j)
// {
// // we want a reducted covariance matrix
// _varcovar(i, j) = var(i, j) / p_size;
// }
// }
// for (unsigned int i = 0; i < s_size; ++i)
// {
// // triangular LOWER matrix, thus j is not going further than i
// for (unsigned int j = 0; j <= i; ++j)
// {
// // we want a reducted covariance matrix
// _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
ublas::scalar_vector< AtomType > u( p_size, 1 );
// unit vector
ublas::scalar_vector< AtomType > u( p_size, 1 );
// sum over columns
_mean = ublas::prod( ublas::trans( sample ), u );
// sum over columns
_mean = ublas::prod( ublas::trans( sample ), u );
// division by n
_mean /= p_size;
}
// division by n
_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:
ublas::symmetric_matrix< AtomType, ublas::lower > _varcovar;
ublas::vector< AtomType > _mean;
ublas::symmetric_matrix< AtomType, ublas::lower > _varcovar;
ublas::vector< AtomType > _mean;
};
public:
@ -137,16 +139,102 @@ public:
edoNormalMulti< EOT > operator()(eoPop<EOT>& pop)
{
unsigned int popsize = pop.size();
assert(popsize > 0);
unsigned int popsize = pop.size();
assert(popsize > 0);
unsigned int dimsize = pop[0].size();
assert(dimsize > 0);
unsigned int dimsize = pop[0].size();
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

69
edo/src/edoNormalMulti.h
View file

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

33
edo/src/edoNormalMultiCenter.h
View file

@ -31,6 +31,8 @@ Authors:
#include "edoModifierMass.h"
#include "edoNormalMulti.h"
#ifdef WITH_BOOST
//! edoNormalMultiCenter< EOT >
template < typename EOT >
@ -41,10 +43,35 @@ public:
void operator() ( edoNormalMulti< EOT >& distrib, EOT& mass )
{
ublas::vector< AtomType > mean( distrib.size() );
std::copy( mass.begin(), mass.end(), mean.begin() );
distrib.mean() = mean;
ublas::vector< AtomType > mean( distrib.size() );
std::copy( mass.begin(), mass.end(), mean.begin() );
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

92
edo/src/edoSamplerNormalMulti.h
View file

@ -32,9 +32,6 @@ Authors:
#include <limits>
#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.
*
@ -43,6 +40,13 @@ Authors:
* - compute the Cholesky decomposition L of V (i.e. such as V=LL*)
* - 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 > >
class edoSamplerNormalMulti : public edoSampler< EOD >
{
@ -84,4 +88,86 @@ protected:
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

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

@ -27,6 +27,9 @@ Authors:
namespace cholesky {
#ifdef WITH_BOOST
/** Cholesky decomposition, given a matrix V, return a matrix 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

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

@ -28,13 +28,24 @@ Authors:
#ifndef _edoStatNormalMulti_h
#define _edoStatNormalMulti_h
#include <boost/numeric/ublas/io.hpp>
#include<sstream>
#include "edoStat.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 >
class edoStatNormalMulti : public edoDistribStat< edoNormalMulti< EOT > >
{
@ -44,27 +55,28 @@ public:
using edoDistribStat< edoNormalMulti< EOT > >::value;
edoStatNormalMulti( std::string desc = "" )
: edoDistribStat< edoNormalMulti< EOT > >( desc )
: edoDistribStat< edoNormalMulti< EOT > >( desc )
{}
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();
// std::copy(mean.begin(), mean.end(), std::ostream_iterator< std::string >( os, " " ));
// ublas::vector< AtomType > mean = distrib.mean();
// std::copy(mean.begin(), mean.end(), std::ostream_iterator< std::string >( os, " " ));
// ublas::symmetric_matrix< AtomType, ublas::lower > varcovar = distrib.varcovar();
// std::copy(varcovar.begin(), varcovar.end(), std::ostream_iterator< std::string >( os, " " ));
// ublas::symmetric_matrix< AtomType, ublas::lower > varcovar = distrib.varcovar();
// 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

2
edo/test/CMakeLists.txt
View file

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

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

@ -40,22 +40,29 @@ typedef eoReal< eoMinimizingFitness > EOT;
typedef edoNormalMulti< EOT > Distrib;
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)
{
//-----------------------------------------------------
// (0) parser + eo routines
//-----------------------------------------------------
eoParser parser(ac, av);
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
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
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 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";
std::string gen_filename = ss.str();
if (parser.userNeedsHelp())
{
parser.printHelp(std::cout);
exit(1);
}
if( parser.userNeedsHelp() ) {
parser.printHelp(std::cout);
exit(1);
}
make_verbose(parser);
make_help(parser);
assert(p_size > 0);
assert(s_size > 0);
eoState state;
//-----------------------------------------------------
//-----------------------------------------------------
// (1) Population init and sampler
//-----------------------------------------------------
eoRndGenerator< double >* gen = new eoUniformGenerator< double >(-5, 5);
state.storeFunctor(gen);
@ -99,18 +97,14 @@ int main(int ac, char** av)
// fill population thanks to eoInit instance
eoPop< EOT >& pop = state.takeOwnership( eoPop< EOT >( p_size, *init ) );
//-----------------------------------------------------
//-----------------------------------------------------------------------------
// (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; }
ublas::symmetric_matrix< AtomType, ublas::lower > varcovar( s_size, s_size );
Matrix varcovar( s_size, s_size );
varcovar( 0, 0 ) = covar1_value;
varcovar( 0, 1 ) = covar2_value;
@ -118,13 +112,7 @@ int main(int ac, char** av)
Distrib distrib( mean, varcovar );
//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
// (3a) distribution output preparation
//-----------------------------------------------------------------------------
edoDummyContinue< Distrib >* distrib_dummy_continue = new edoDummyContinue< Distrib >();
state.storeFunctor(distrib_dummy_continue);
@ -141,60 +129,29 @@ int main(int ac, char** av)
distrib_file_snapshot->add(*distrib_stat);
distrib_continue->add(*distrib_file_snapshot);
//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
// (3b) distribution output
//-----------------------------------------------------------------------------
(*distrib_continue)( distrib );
//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
// 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);
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 );
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 );
}
for( unsigned int i = 0; i < p_size; ++i ) {
EOT candidate_solution = (*sampler)( distrib );
pop.push_back( candidate_solution );
}
//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
// (5) population output
//-----------------------------------------------------------------------------
eoContinue< EOT >* pop_cont = new eoGenContinue< EOT >( 2 ); // never reached fitness
state.storeFunctor(pop_cont);
@ -212,53 +169,31 @@ int main(int ac, char** av)
(*pop_continue)( pop );
//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
// (6) estimation phase
//-----------------------------------------------------------------------------
edoEstimator< Distrib >* estimator = new edoEstimatorNormalMulti< EOT >();
state.storeFunctor(estimator);
distrib = (*estimator)( pop );
//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
// (7) distribution output
//-----------------------------------------------------------------------------
(*distrib_continue)( distrib );
//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
// (8) euclidianne distance estimation
//-----------------------------------------------------------------------------
ublas::vector< AtomType > new_mean = distrib.mean();
ublas::symmetric_matrix< AtomType, ublas::lower > new_varcovar = distrib.varcovar();
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 );
}
for( unsigned int d = 0; d < s_size; ++d ) {
distance += pow( mean[ d ] - new_mean[ d ], 2 );
}
distance = sqrt( distance );
eo::log << eo::logging
<< "mean: " << mean << std::endl
<< "new mean: " << new_mean << std::endl
<< "distance: " << distance << std::endl
;
//-----------------------------------------------------------------------------
<< "mean: " << mean << std::endl
<< "new mean: " << new_mean << std::endl
<< "distance: " << distance << std::endl
;
return 0;
}

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

@ -37,25 +37,33 @@ Authors:
#include <edo>
#include <boost/numeric/ublas/vector.hpp>
#include <boost/numeric/ublas/symmetric.hpp>
#include "Rosenbrock.h"
#include "Sphere.h"
typedef eoReal< eoMinimizingFitness > EOT;
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)
{
//-----------------------------------------------------
// (0) parser + eo routines
//-----------------------------------------------------
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 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
if (parser.userNeedsHelp())
{
parser.printHelp(std::cout);
exit(1);
}
{
parser.printHelp(std::cout);
exit(1);
}
make_verbose(parser);
make_help(parser);
//-----------------------------------------------------
assert(r_max >= 1);
assert(s_size >= 2);
@ -90,139 +98,146 @@ int main(int ac, char** av)
::mkdir( results_directory.c_str(), 0755 );
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;
desc_file << results_directory << "/" << files_description;
std::ostringstream desc_file;
desc_file << results_directory << "/" << files_description;
std::ostringstream cur_file;
cur_file << results_directory << "/pop_" << p_size << ".txt";
std::ostringstream cur_file;
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);
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 ) );
//-----------------------------------------------------
// (1) Population init and sampler
//-----------------------------------------------------------------------------
// (2) distribution initial parameters
//-----------------------------------------------------------------------------
eoRndGenerator< double >* gen = new eoUniformGenerator< double >(-5, 5);
state.storeFunctor(gen);
ublas::vector< AtomType > mean( s_size, mean_value );
ublas::symmetric_matrix< AtomType, ublas::lower > varcovar( s_size, s_size );
eoInitFixedLength< EOT >* init = new eoInitFixedLength< EOT >( s_size, *gen );
state.storeFunctor(init);
varcovar( 0, 0 ) = covar1_value;
varcovar( 0, 1 ) = covar2_value;
varcovar( 1, 1 ) = covar3_value;
Distrib distrib( mean, varcovar );
//-----------------------------------------------------------------------------
// 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 ) );
//-----------------------------------------------------------------------------
// 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 );
state.storeFunctor(sampler);
//-----------------------------------------------------------------------------
// (2) distribution initial parameters
//-----------------------------------------------------------------------------
// (4) sampling phase
//-----------------------------------------------------------------------------
#ifdef WITH_BOOST
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)
{
EOT candidate_solution = (*sampler)( distrib );
pop.push_back( candidate_solution );
}
//-----------------------------------------------------------------------------
Distrib distrib( mean, varcovar );
//-----------------------------------------------------------------------------
// (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();
ublas::symmetric_matrix< AtomType, ublas::lower > new_varcovar = distrib.varcovar();
// Prepare bounder class to set bounds of sampling.
// This is used by edoSampler.
AtomType distance = 0;
for ( unsigned int d = 0; d < s_size; ++d )
{
distance += pow( mean[ d ] - new_mean[ d ], 2 );
}
edoBounder< EOT >* bounder = new edoBounderRng< EOT >(EOT(pop[0].size(), -5),
EOT(pop[0].size(), 5),
*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;
}

28
eo/NEWS
View file

@ -1,4 +1,22 @@
* current version
- features:
- delete the deprecated code parts (was marked as deprecated in the release 1.1)
- eoSignal: a class to handle signal with eoCheckpoint instances
- eoDetSingleBitFlip: bit flip mutation that changes exactly k bits while checking for duplicate
- eoFunctorStat: a wrapper to turn any stand-alone function and into an eoStat
- generilazed the output of an eoState: now you can change the format, comes with defaults formatting (latex and json)
- eoWrongParamTypeException: a new exception to handle cases where a wrong template is given to eoParser::valueOf
- added a getParam method to the eoParser, that raise an exception if the parameter has not been declared
- eoParserLogger features are now included in the default eoParser
- build system:
- improvements of the build architecture
- create PKGBUILD file for archlinux package manager
- a FindEO module for CMake
- bugfixes:
- fixed regression with gcc 4.7
- fixed compilation issues in Microsoft Visual C++, related to time measurement
- added several asserts accross the framework (note: asserts are included only in debug mode)
- lot of small bugfixes :-)
* release 1.2 (16. May. 2011)
- fixed the incremental allocation issue in variation operators which were
@ -20,11 +38,11 @@
- GCC 4.3 compatibility
- new versatile log system with several nested verbose levels
- classes using intern verbose parameters marked as deprecated, please update your code accordingly if you use one of the following files:
eo/src/eoCombinedInit.h
eo/src/eoGenContinue.h
eo/src/eoProportionalCombinedOp.h
eo/src/utils/eoData.h
eo/src/utils/eoStdoutMonitor.h
eo/src/eoCombinedInit.h
eo/src/eoGenContinue.h
eo/src/eoProportionalCombinedOp.h
eo/src/utils/eoData.h
eo/src/utils/eoStdoutMonitor.h
- an evaluator that throw an exception if a maximum eval numbers has been reached, independently of the number of generations
- new monitor that can write on any ostream
- new continuator that can catch POSIX system user signals

12
eo/src/apply.h
View file

@ -58,14 +58,26 @@ void apply(eoUF<EOT&, void>& _proc, std::vector<EOT>& _pop)
if (!eo::parallel.isDynamic())
{
#pragma omp parallel for if(eo::parallel.isEnabled()) //default(none) shared(_proc, _pop, size)
#ifdef _MSC_VER
//Visual Studio supports only OpenMP version 2.0 in which
//an index variable must be of a signed integral type
for (long long i = 0; i < size; ++i) { _proc(_pop[i]); }
#else // _MSC_VER
for (size_t i = 0; i < size; ++i) { _proc(_pop[i]); }
#endif
}
else
{
#pragma omp parallel for schedule(dynamic) if(eo::parallel.isEnabled())
#ifdef _MSC_VER
//Visual Studio supports only OpenMP version 2.0 in which
//an index variable must be of a signed integral type
for (long long i = 0; i < size; ++i) { _proc(_pop[i]); }
#else // _MSC_VER
//doesnot work with gcc 4.1.2
//default(none) shared(_proc, _pop, size)
for (size_t i = 0; i < size; ++i) { _proc(_pop[i]); }
#endif
}
if ( eo::parallel.enableResults() )

59
eo/src/eoEvalUserTimeThrowException.h
View file

@ -21,27 +21,30 @@ Authors:
Johann Dréo <johann.dreo@thalesgroup.com>
*/
#ifndef __unix__
#warning "Warning: class 'eoEvalUserTimeThrowException' is only available under UNIX systems (defining 'rusage' in 'sys/resource.h'), contributions for other systems are welcomed."
#else
#if !defined(__unix__) && !defined(_WINDOWS)
#warning "Warning: class 'eoEvalUserTimeThrowException' is only available under UNIX (defining 'rusage' in 'sys/resource.h') or Win32 (defining 'GetProcessTimes' in 'WinBase.h') systems, contributions for other systems are welcomed."
#else //!defined(__unix__) && !defined(_WINDOWS)
#ifndef __EOEVALUSERTIMETHROWEXCEPTION_H__
#define __EOEVALUSERTIMETHROWEXCEPTION_H__
#include <sys/time.h>
#include <sys/resource.h>
#include <eoExceptions.h>
/** Check at each evaluation if a given CPU user time contract has been reached.
*
* Throw an eoMaxTimeException if the given max time has been reached.
* Usefull if you want to end the search independently of generations.
* This class uses (almost-)POSIX headers.
* This class uses (almost-)POSIX or Win32 headers, depending on the platform.
* It uses a computation of the user time used on the CPU. For a wallclock time measure, see eoEvalTimeThrowException
*
* @ingroup Evaluation
*/
#include <eoExceptions.h>
#ifdef __unix__
#include <sys/time.h>
#include <sys/resource.h>
template< class EOT >
class eoEvalUserTimeThrowException : public eoEvalFuncCounter< EOT >
{
@ -68,5 +71,41 @@ protected:
struct rusage _usage;
};
#else
#ifdef _WINDOWS
//here _WINDOWS is defined
#include <WinBase.h>
template< class EOT >
class eoEvalUserTimeThrowException : public eoEvalFuncCounter< EOT >
{
public:
eoEvalUserTimeThrowException( eoEvalFunc<EOT> & func, const long max ) : eoEvalFuncCounter<EOT>( func, "CPU-user"), _max(max) {}
virtual void operator() ( EOT & eo )
{
if( eo.invalid() ) {
FILETIME dummy;
GetProcessTimes(GetCurrentProcess(), &dummy, &dummy, &dummy, &_usage);
ULARGE_INTEGER current;
current.LowPart = _usage.dwLowDateTime;
current.HighPart = _usage.dwHighDateTime;
if( current.QuadPart >= _max ) {
throw eoMaxTimeException( current.QuadPart );
} else {
func(eo);
}
}
}
protected:
const long _max;
FILETIME _usage;
};
#endif // _WINDOWS
#endif //__unix__
#endif // __EOEVALUSERTIMETHROWEXCEPTION_H__
#endif // __UNIX__
#endif //!defined(__unix__) && !defined(_WINDOWS)