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 2011-10-03 15:41:57 +02:00
commit f7c4c53d09
26 changed files with 702 additions and 637 deletions
Download patch file Download diff file Expand all files Collapse all files

2
edo/CMakeLists.txt
View file

@ -42,7 +42,6 @@ INCLUDE_DIRECTORIES(
LINK_DIRECTORIES( LINK_DIRECTORIES(
${EO_LIBRARY_DIRS} ${EO_LIBRARY_DIRS}
${MO_LIBRARY_DIRS}
) )
###################################################################################### ######################################################################################
@ -77,6 +76,7 @@ ENDIF()
### 6) Prepare some variables for CMAKE usage ### 6) Prepare some variables for CMAKE usage
###################################################################################### ######################################################################################
# Empty source files, because we want to build a library
SET(SAMPLE_SRCS) SET(SAMPLE_SRCS)
###################################################################################### ######################################################################################

2
edo/application/eda/CMakeLists.txt
View file

@ -24,4 +24,4 @@ FILE(GLOB SOURCES *.cpp)
SET(EXECUTABLE_OUTPUT_PATH ${EDO_BINARY_DIR}) SET(EXECUTABLE_OUTPUT_PATH ${EDO_BINARY_DIR})
ADD_EXECUTABLE(${PROJECT_NAME} ${SOURCES}) ADD_EXECUTABLE(${PROJECT_NAME} ${SOURCES})
TARGET_LINK_LIBRARIES(${PROJECT_NAME} edo edoutils ${EO_LIBRARIES} ${MO_LIBRARIES} ${Boost_LIBRARIES}) TARGET_LINK_LIBRARIES(${PROJECT_NAME} edo edoutils ${EO_LIBRARIES} ${Boost_LIBRARIES})

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

@ -52,32 +52,19 @@ int main(int ac, char** av)
// Letters used by the following declarations: // Letters used by the following declarations:
// a d i p t // a d i p t
std::string section("Algorithm parameters"); std::string section("Algorithm parameters");
// FIXME: default value to check
//double initial_temperature = parser.createParam((double)10e5, "temperature", "Initial temperature", 'i', section).value(); // i
eoState state; eoState state;
//-----------------------------------------------------------------------------
// Instantiate all needed parameters for EDA algorithm // Instantiate all needed parameters for EDA algorithm
//-----------------------------------------------------------------------------
double selection_rate = parser.createParam((double)0.5, "selection_rate", "Selection Rate", 'R', section).value(); // R double selection_rate = parser.createParam((double)0.5, "selection_rate", "Selection Rate", 'R', section).value(); // R
eoSelect< EOT >* selector = new eoDetSelect< EOT >( selection_rate ); eoSelect< EOT >* selector = new eoDetSelect< EOT >( selection_rate );
state.storeFunctor(selector); state.storeFunctor(selector);
edoEstimator< Distrib >* estimator = new edoEstimatorNormalMulti< EOT >(); edoEstimator< Distrib >* estimator = new edoEstimatorNormalMulti< EOT >();
state.storeFunctor(estimator); state.storeFunctor(estimator);
eoSelectOne< EOT >* selectone = new eoDetTournamentSelect< EOT >( 2 );
state.storeFunctor(selectone);
edoModifierMass< Distrib >* modifier = new edoNormalMultiCenter< EOT >();
state.storeFunctor(modifier);
eoEvalFunc< EOT >* plainEval = new Rosenbrock< EOT >(); eoEvalFunc< EOT >* plainEval = new Rosenbrock< EOT >();
state.storeFunctor(plainEval); state.storeFunctor(plainEval);
@ -87,159 +74,65 @@ int main(int ac, char** av)
eoRndGenerator< double >* gen = new eoUniformGenerator< double >(-5, 5); eoRndGenerator< double >* gen = new eoUniformGenerator< double >(-5, 5);
state.storeFunctor(gen); state.storeFunctor(gen);
unsigned int dimension_size = parser.createParam((unsigned int)10, "dimension-size", "Dimension size", 'd', section).value(); // d 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 ); eoInitFixedLength< EOT >* init = new eoInitFixedLength< EOT >( dimension_size, *gen );
state.storeFunctor(init); state.storeFunctor(init);
//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
// (1) Population init and sampler // (1) Population init and sampler
//-----------------------------------------------------------------------------
// Generation of population from do_make_pop (creates parameters, manages persistance and so on...) // Generation of population from do_make_pop (creates parameters, manages persistance and so on...)
// ... and creates the parameters: L P r S // ... and creates the parameters: L P r S
// this first sampler creates a uniform distribution independently from our distribution (it does not use edoUniform).
// this first sampler creates a uniform distribution independently from our distribution (it does not use doUniform).
eoPop< EOT >& pop = do_make_pop(parser, state, *init); eoPop< EOT >& pop = do_make_pop(parser, state, *init);
//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
// (2) First evaluation before starting the research algorithm // (2) First evaluation before starting the research algorithm
//-----------------------------------------------------------------------------
apply(eval, pop); apply(eval, pop);
//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
// Prepare bounder class to set bounds of sampling. // Prepare bounder class to set bounds of sampling.
// This is used by doSampler. // 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
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);
//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
// Metropolis sample parameters
//-----------------------------------------------------------------------------
//unsigned int popSize = parser.getORcreateParam((unsigned int)20, "popSize", "Population Size", 'P', "Evolution Engine").value();
//moContinuator< moDummyNeighbor<EOT> >* sa_continue = new moIterContinuator< moDummyNeighbor<EOT> >( popSize );
//state.storeFunctor(sa_continue);
//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
// SA parameters
//-----------------------------------------------------------------------------
//double threshold_temperature = parser.createParam((double)0.1, "threshold", "Minimal temperature at which stop", 't', section).value(); // t
//double alpha = parser.createParam((double)0.1, "alpha", "Temperature decrease rate", 'a', section).value(); // a
//moCoolingSchedule<EOT>* cooling_schedule = new moSimpleCoolingSchedule<EOT>(initial_temperature, alpha, 0, threshold_temperature);
//state.storeFunctor(cooling_schedule);
//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
// stopping criteria // stopping criteria
// ... and creates the parameter letters: C E g G s T // ... and creates the parameter letters: C E g G s T
//-----------------------------------------------------------------------------
eoContinue< EOT >& eo_continue = do_make_continue(parser, state, eval); eoContinue< EOT >& eo_continue = do_make_continue(parser, state, eval);
//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
// population output // population output
//-----------------------------------------------------------------------------
eoCheckPoint< EOT >& pop_continue = do_make_checkpoint(parser, state, eval, eo_continue); eoCheckPoint< EOT >& pop_continue = do_make_checkpoint(parser, state, eval, eo_continue);
//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
// distribution output // distribution output
//-----------------------------------------------------------------------------
edoDummyContinue< Distrib >* dummy_continue = new edoDummyContinue< Distrib >(); edoDummyContinue< Distrib >* dummy_continue = new edoDummyContinue< Distrib >();
state.storeFunctor(dummy_continue); state.storeFunctor(dummy_continue);
edoCheckPoint< Distrib >* distribution_continue = new edoCheckPoint< Distrib >( *dummy_continue ); edoCheckPoint< Distrib >* distribution_continue = new edoCheckPoint< Distrib >( *dummy_continue );
state.storeFunctor(distribution_continue); state.storeFunctor(distribution_continue);
//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
// eoEPRemplacement causes the using of the current and previous // eoEPRemplacement causes the using of the current and previous
// sample for sampling. // sample for sampling.
//-----------------------------------------------------------------------------
eoReplacement< EOT >* replacor = new eoEPReplacement< EOT >(pop.size()); eoReplacement< EOT >* replacor = new eoEPReplacement< EOT >(pop.size());
// Below, use eoGenerationalReplacement to sample only on the current sample
//eoReplacement< EOT >* replacor = new eoGenerationalReplacement< EOT >(); // FIXME: to define the size
state.storeFunctor(replacor); state.storeFunctor(replacor);
//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
// 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())
{ {
parser.printHelp(std::cout); parser.printHelp(std::cout);
exit(1); exit(1);
} }
// Help + Verbose routines // Help + Verbose routines
make_verbose(parser); make_verbose(parser);
make_help(parser); make_help(parser);
//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
// population output (after helper) // population output (after helper)
// //
// FIXME: theses objects are instanciate there in order to avoid a folder // FIXME: theses objects are instanciated there in order to avoid a folder
// removing as doFileSnapshot does within ctor. // removing as edoFileSnapshot does within ctor.
//-----------------------------------------------------------------------------
edoPopStat< EOT >* popStat = new edoPopStat<EOT>; edoPopStat< EOT >* popStat = new edoPopStat<EOT>;
state.storeFunctor(popStat); state.storeFunctor(popStat);
pop_continue.add(*popStat); pop_continue.add(*popStat);
@ -249,13 +142,7 @@ int main(int ac, char** av)
fileSnapshot->add(*popStat); fileSnapshot->add(*popStat);
pop_continue.add(*fileSnapshot); pop_continue.add(*fileSnapshot);
//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
// distribution output (after helper) // distribution output (after helper)
//-----------------------------------------------------------------------------
edoDistribStat< Distrib >* distrib_stat = new edoStatNormalMulti< EOT >(); edoDistribStat< Distrib >* distrib_stat = new edoStatNormalMulti< EOT >();
state.storeFunctor(distrib_stat); state.storeFunctor(distrib_stat);
@ -271,42 +158,24 @@ int main(int ac, char** av)
file_monitor->add(*distrib_stat); file_monitor->add(*distrib_stat);
distribution_continue->add( *file_monitor ); distribution_continue->add( *file_monitor );
//----------------------------------------------------------------------------- eoPopLoopEval<EOT> popEval( eval );
//-----------------------------------------------------------------------------
// EDA algorithm configuration // EDA algorithm configuration
//-----------------------------------------------------------------------------
edoAlgo< Distrib >* algo = new edoEDA< Distrib > edoAlgo< Distrib >* algo = new edoEDA< Distrib >
(*selector, *estimator, *selectone, *modifier, *sampler, (*selector, *estimator, *sampler,
pop_continue, *distribution_continue, pop_continue, *distribution_continue,
eval, popEval, *replacor);
//*sa_continue, *cooling_schedule, initial_temperature,
*replacor);
//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
// Beginning of the algorithm call // Beginning of the algorithm call
//----------------------------------------------------------------------------- try {
do_run(*algo, pop);
try } catch (eoEvalFuncCounterBounderException& e) {
{ eo::log << eo::warnings << "warning: " << e.what() << std::endl;
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);
}
//-----------------------------------------------------------------------------
} catch (std::exception& e) {
eo::log << eo::errors << "error: " << e.what() << std::endl;
exit(EXIT_FAILURE);
}
return 0; return 0;
} }

2
edo/install.cmake-dist
View file

@ -8,7 +8,7 @@ SET(MO_DIR "<<PATH_TO_MO>>" CACHE PATH "MO directory" FORCE)
SET(EO_INCLUDE_DIRS "${EO_DIR}/src" CACHE PATH "EO include directory" FORCE) SET(EO_INCLUDE_DIRS "${EO_DIR}/src" CACHE PATH "EO include directory" FORCE)
SET(EO_LIBRARY_DIRS "${EO_DIR}/release/lib" CACHE PATH "EO library directory" FORCE) SET(EO_LIBRARY_DIRS "${EO_DIR}/release/lib" CACHE PATH "EO library directory" FORCE)
SET(EO_LIBRARIES "eoutils eo es ga cma gcov") SET(EO_LIBRARIES eoutils eo es ga cma gcov) # do not use quotes around this list or it will fail
SET(MO_INCLUDE_DIRS "${MO_DIR}/src" CACHE PATH "MO include directory" FORCE) SET(MO_INCLUDE_DIRS "${MO_DIR}/src" CACHE PATH "MO include directory" FORCE)
SET(MO_LIBRARY_DIRS "${MO_DIR}/release/lib" CACHE PATH "MO library directory" FORCE) SET(MO_LIBRARY_DIRS "${MO_DIR}/release/lib" CACHE PATH "MO library directory" FORCE)

4
edo/src/edo
View file

@ -56,10 +56,14 @@ Authors:
#include "edoVectorBounds.h" #include "edoVectorBounds.h"
#include "edoRepairer.h"
#include "edoRepairerDispatcher.h"
#include "edoRepairerRound.h"
#include "edoBounder.h" #include "edoBounder.h"
#include "edoBounderNo.h" #include "edoBounderNo.h"
#include "edoBounderBound.h" #include "edoBounderBound.h"
#include "edoBounderRng.h" #include "edoBounderRng.h"
#include "edoBounderUniform.h"
#include "edoContinue.h" #include "edoContinue.h"
#include "utils/edoCheckPoint.h" #include "utils/edoCheckPoint.h"

9
edo/src/edoAlgo.h
View file

@ -31,14 +31,19 @@ Authors:
#include <eoAlgo.h> #include <eoAlgo.h>
//! edoAlgo< D > /** An EDO algorithm difffers from a canonical EO algorithm because it is
* templatized on a Distribution rather than just an EOT.
*
* Derivating from an eoAlgo, it should define an operator()( EOT sol )
*/
template < typename D > template < typename D >
class edoAlgo : public eoAlgo< typename D::EOType > class edoAlgo : public eoAlgo< typename D::EOType >
{ {
//! Alias for the type //! Alias for the type
typedef typename D::EOType EOT; typedef typename D::EOType EOT;
// virtual R operator()(A1) = 0; (defined in eoUF)
public: public:
virtual ~edoAlgo(){} virtual ~edoAlgo(){}
}; };

23
edo/src/edoBounder.h
View file

@ -28,19 +28,26 @@ Authors:
#ifndef _edoBounder_h #ifndef _edoBounder_h
#define _edoBounder_h #define _edoBounder_h
#include <eoFunctor.h> #include <edoRepairer.h>
//! edoBounder< EOT >
/** The interface of a set of classes that modifies a solution so as to respect
* a given set of bounds (typically an hypercube).
*
* @ingroup Repairers
*/
template < typename EOT > template < typename EOT >
class edoBounder : public eoUF< EOT&, void > class edoBounder : public edoRepairer< EOT >
{ {
public: public:
edoBounder( EOT min = EOT(1, 0), EOT max = EOT(1, 0) ) edoBounder()
: _min(min), _max(max) {}
edoBounder( EOT min/* = EOT(1, 0)*/, EOT max/* = EOT(1, 1)*/ )
: _min(min), _max(max)
{ {
assert(_min.size() > 0); assert(_min.size() > 0);
assert(_min.size() == _max.size()); assert(_min.size() == _max.size());
} }
// virtual void operator()( EOT& ) = 0 (provided by eoUF< A1, R >) // virtual void operator()( EOT& ) = 0 (provided by eoUF< A1, R >)

36
edo/src/edoBounderBound.h
View file

@ -30,34 +30,36 @@ Authors:
#include "edoBounder.h" #include "edoBounder.h"
//! edoBounderBound< EOT > /** A bounder that correct an incorrect variable by setting it to the min/max
*
* @ingroup Repairers
*/
template < typename EOT > template < typename EOT >
class edoBounderBound : public edoBounder< EOT > class edoBounderBound : public edoBounder< EOT >
{ {
public: public:
edoBounderBound( EOT min, EOT max ) edoBounderBound( EOT min, EOT max )
: edoBounder< EOT >( min, max ) : edoBounder< EOT >( min, max )
{} {}
void operator()( EOT& x ) void operator()( EOT& x )
{ {
unsigned int size = x.size(); unsigned int size = x.size();
assert(size > 0); assert(size > 0);
for (unsigned int d = 0; d < size; ++d) // browse all dimensions for (unsigned int d = 0; d < size; ++d) // browse all dimensions
{ {
if (x[d] < this->min()[d]) if (x[d] < this->min()[d])
{ {
x[d] = this->min()[d]; x[d] = this->min()[d];
continue; continue;
} }
if (x[d] > this->max()[d]) if (x[d] > this->max()[d])
{ {
x[d] = this->max()[d]; x[d] = this->max()[d];
} }
} }
} }
}; };

6
edo/src/edoBounderNo.h
View file

@ -30,8 +30,10 @@ Authors:
#include "edoBounder.h" #include "edoBounder.h"
//! edoBounderNo< EOT > /** A bounder that does nothing.
*
* @ingroup Repairers
*/
template < typename EOT > template < typename EOT >
class edoBounderNo : public edoBounder< EOT > class edoBounderNo : public edoBounder< EOT >
{ {

29
edo/src/edoBounderRng.h
View file

@ -30,31 +30,34 @@ Authors:
#include "edoBounder.h" #include "edoBounder.h"
//! edoBounderRng< EOT > /** A bounder that randomly draw new values for variables going out bounds,
* using an eoRng to do so.
*
* @ingroup Repairers
*/
template < typename EOT > template < typename EOT >
class edoBounderRng : public edoBounder< EOT > class edoBounderRng : public edoBounder< EOT >
{ {
public: public:
edoBounderRng( EOT min, EOT max, eoRndGenerator< double > & rng ) edoBounderRng( EOT min, EOT max, eoRndGenerator< double > & rng )
: edoBounder< EOT >( min, max ), _rng(rng) : edoBounder< EOT >( min, max ), _rng(rng)
{} {}
void operator()( EOT& x ) void operator()( EOT& x )
{ {
unsigned int size = x.size(); unsigned int size = x.size();
assert(size > 0); assert(size > 0);
for (unsigned int d = 0; d < size; ++d) // browse all dimensions for (unsigned int d = 0; d < size; ++d) // browse all dimensions
{ {
// FIXME: attention: les bornes RNG ont les memes bornes quelque soit les dimensions idealement on voudrait avoir des bornes differentes pour chaque dimensions. // FIXME: attention: les bornes RNG ont les memes bornes quelque soit les dimensions idealement on voudrait avoir des bornes differentes pour chaque dimensions.
if (x[d] < this->min()[d] || x[d] > this->max()[d]) if (x[d] < this->min()[d] || x[d] > this->max()[d])
{ {
x[d] = _rng(); x[d] = _rng();
} }
} }
} }
private: private:

31
edo/src/edoBounderUniform.h
View file

@ -29,28 +29,35 @@ Authors:
#include "edoBounder.h" #include "edoBounder.h"
//! edoBounderUniform< EOT > /** A bounder that randomly draw new values for variables going out bounds,
* in a given uniform distribution.
*
* @ingroup Repairers
*/
template < typename EOT > template < typename EOT >
class edoBounderUniform : public edoBounder< EOT > class edoBounderUniform : public edoBounder< EOT >
{ {
public: public:
edoBounderUniform( EOT min, EOT max ) edoBounderUniform( EOT min, EOT max )
: edoBounder< EOT >( min, max ) : edoBounder< EOT >( min, max )
{} {
}
void operator()( EOT& sol ) void operator()( EOT& sol )
{ {
unsigned int size = sol.size(); assert( this->min().size() > 0 );
assert(size > 0); assert( this->max().size() > 0 );
for (unsigned int d = 0; d < size; ++d) { assert( sol.size() > 0);
if ( sol[d] < this->min()[d] || sol[d] > this->max()[d]) { unsigned int size = sol.size();
// use EO's global "rng" for (unsigned int d = 0; d < size; ++d) {
sol[d] = rng.uniform( this->min()[d], this->max()[d] );
} if ( sol[d] < this->min()[d] || sol[d] > this->max()[d]) {
} // for d in size // use EO's global "rng"
sol[d] = rng.uniform( this->min()[d], this->max()[d] );
}
} // for d in size
} }
}; };

279
edo/src/edoEDA.h
View file

@ -58,217 +58,138 @@ public:
//! edoEDA constructor //! edoEDA constructor
/*! /*!
All the boxes used by a EDASA need to be given. Takes algo operators, all are mandatory
\param selector Population Selector \param evaluation Evaluate a population
\param estimator Distribution Estimator \param selector Selection of the best candidate solutions in the population
\param selectone SelectOne \param estimator Estimation of the distribution parameters
\param modifier Distribution Modifier \param sampler Generate feasible solutions using the distribution
\param sampler Distribution Sampler \param replacor Replace old solutions by new ones
\param pop_continue Population Continuator \param pop_continuator Stopping criterion based on the population features
\param distribution_continue Distribution Continuator \param distribution_continuator Stopping criterion based on the distribution features
\param evaluation Evaluation function.
\param sa_continue Stopping criterion.
\param cooling_schedule Cooling schedule, describes how the temperature is modified.
\param initial_temperature The initial temperature.
\param replacor Population replacor
*/ */
edoEDA (eoSelect< EOT > & selector, edoEDA (
edoEstimator< D > & estimator, eoPopEvalFunc < EOT > & evaluator,
eoSelectOne< EOT > & selectone, eoSelect< EOT > & selector,
edoModifierMass< D > & modifier, edoEstimator< D > & estimator,
edoSampler< D > & sampler, edoSampler< D > & sampler,
eoContinue< EOT > & pop_continue, eoReplacement< EOT > & replacor,
edoContinue< D > & distribution_continue, eoContinue< EOT > & pop_continuator,
eoEvalFunc < EOT > & evaluation, edoContinue< D > & distribution_continuator
//moContinuator< moDummyNeighbor<EOT> > & sa_continue, ) :
//moCoolingSchedule<EOT> & cooling_schedule, _evaluator(evaluator),
//double initial_temperature, _selector(selector),
eoReplacement< EOT > & replacor _estimator(estimator),
) _sampler(sampler),
: _selector(selector), _replacor(replacor),
_estimator(estimator), _pop_continuator(pop_continuator),
_selectone(selectone), _dummy_continue(),
_modifier(modifier), _distribution_continuator(distribution_continuator)
_sampler(sampler),
_pop_continue(pop_continue),
_distribution_continue(distribution_continue),
_evaluation(evaluation),
//_sa_continue(sa_continue),
//_cooling_schedule(cooling_schedule),
//_initial_temperature(initial_temperature),
_replacor(replacor)
{} {}
//! function that launches the EDASA algorithm. //! edoEDA constructor without an edoContinue
/*! /*!
As a moTS or a moHC, the EDASA can be used for HYBRIDATION in an evolutionary algorithm. Takes algo operators, all are mandatory
\param pop A population to improve. \param evaluation Evaluate a population
\return TRUE. \param selector Selection of the best candidate solutions in the population
\param estimator Estimation of the distribution parameters
\param sampler Generate feasible solutions using the distribution
\param replacor Replace old solutions by new ones
\param pop_continuator Stopping criterion based on the population features
*/
edoEDA (
eoPopEvalFunc < EOT > & evaluator,
eoSelect< EOT > & selector,
edoEstimator< D > & estimator,
edoSampler< D > & sampler,
eoReplacement< EOT > & replacor,
eoContinue< EOT > & pop_continuator
) :
_evaluator(evaluator),
_selector(selector),
_estimator(estimator),
_sampler(sampler),
_replacor(replacor),
_pop_continuator(pop_continuator),
_dummy_continue(),
_distribution_continuator( _dummy_continue )
{}
/** A basic EDA algorithm that iterates over:
* selection, estimation, sampling, bounding, evaluation, replacement
*
* \param pop the population of candidate solutions
* \return void
*/ */
void operator ()(eoPop< EOT > & pop) void operator ()(eoPop< EOT > & pop)
{ {
assert(pop.size() > 0); assert(pop.size() > 0);
//double temperature = _initial_temperature; eoPop< EOT > current_pop;
eoPop< EOT > selected_pop;
eoPop< EOT > current_pop; // FIXME one must instanciate a first distrib here because there is no empty constructor, see if it is possible to instanciate Distributions without parameters
D distrib = _estimator(pop);
eoPop< EOT > selected_pop; // Evaluating a first time the candidate solutions
// The first pop is not supposed to be evaluated (@see eoPopLoopEval).
_evaluator( current_pop, pop );
do {
// (1) Selection of the best points in the population
//selected_pop.clear(); // FIXME is it necessary to clear?
_selector(pop, selected_pop);
assert( selected_pop.size() > 0 );
// TODO: utiliser selected_pop ou pop ???
//------------------------------------------------------------- // (2) Estimation of the distribution parameters
// Estimating a first time the distribution parameter thanks distrib = _estimator(selected_pop);
// to population.
//-------------------------------------------------------------
D distrib = _estimator(pop); // (3) sampling
// The sampler produces feasible solutions (@see edoSampler that
// encapsulate an edoBounder)
current_pop.clear();
for( unsigned int i = 0; i < pop.size(); ++i ) {
current_pop.push_back( _sampler(distrib) );
}
double size = distrib.size(); // (4) Evaluate new solutions
assert(size > 0); _evaluator( pop, current_pop );
//------------------------------------------------------------- // (5) Replace old solutions by new ones
_replacor(pop, current_pop); // e.g. copy current_pop in pop
} while( _distribution_continuator( distrib ) && _pop_continuator( pop ) );
do } // operator()
{
//-------------------------------------------------------------
// (3) Selection of the best points in the population
//-------------------------------------------------------------
selected_pop.clear();
_selector(pop, selected_pop);
assert( selected_pop.size() > 0 );
//-------------------------------------------------------------
//-------------------------------------------------------------
// (4) Estimation of the distribution parameters
//-------------------------------------------------------------
distrib = _estimator(selected_pop);
//-------------------------------------------------------------
// TODO: utiliser selected_pop ou pop ???
assert(selected_pop.size() > 0);
//-------------------------------------------------------------
// Init of a variable contening a point with the bestest fitnesses
//-------------------------------------------------------------
EOT current_solution = _selectone(selected_pop);
//-------------------------------------------------------------
//-------------------------------------------------------------
// Fit the current solution with the distribution parameters (bounds)
//-------------------------------------------------------------
// FIXME: si besoin de modifier la dispersion de la distribution
// _modifier_dispersion(distribution, selected_pop);
_modifier(distrib, current_solution);
//-------------------------------------------------------------
//-------------------------------------------------------------
// Evaluating a first time the current solution
//-------------------------------------------------------------
_evaluation( current_solution );
//-------------------------------------------------------------
//-------------------------------------------------------------
// Building of the sampler in current_pop
//-------------------------------------------------------------
//_sa_continue.init( current_solution );
current_pop.clear();
for ( unsigned int i = 0; i < pop.size(); ++i )
//do
{
EOT candidate_solution = _sampler(distrib);
_evaluation( candidate_solution );
// TODO: verifier le critere d'acceptation
if ( candidate_solution.fitness() < current_solution.fitness()
// || rng.uniform() < exp( ::fabs(candidate_solution.fitness() - current_solution.fitness()) / temperature )
)
{
current_pop.push_back(candidate_solution);
current_solution = candidate_solution;
}
}
//while ( _sa_continue( current_solution) );
//-------------------------------------------------------------
_replacor(pop, current_pop); // copy current_pop in pop
pop.sort();
//if ( ! _cooling_schedule( temperature ) ){ eo::log << eo::debug << "_cooling_schedule" << std::endl; break; }
if ( ! _distribution_continue( distrib ) ){ eo::log << eo::debug << "_distribution_continue" << std::endl; break; }
if ( ! _pop_continue( pop ) ){ eo::log << eo::debug << "_pop_continue" << std::endl; break; }
}
while ( 1 );
}
private: private:
//! A full evaluation function.
eoPopEvalFunc < EOT > & _evaluator;
//! A EOT selector //! A EOT selector
eoSelect < EOT > & _selector; eoSelect < EOT > & _selector;
//! A EOT estimator. It is going to estimate distribution parameters. //! A EOT estimator. It is going to estimate distribution parameters.
edoEstimator< D > & _estimator; edoEstimator< D > & _estimator;
//! SelectOne
eoSelectOne< EOT > & _selectone;
//! A D modifier
edoModifierMass< D > & _modifier;
//! A D sampler //! A D sampler
edoSampler< D > & _sampler; edoSampler< D > & _sampler;
//! A EOT population continuator
eoContinue < EOT > & _pop_continue;
//! A D continuator
edoContinue < D > & _distribution_continue;
//! A full evaluation function.
eoEvalFunc < EOT > & _evaluation;
//! Stopping criterion before temperature update
//moContinuator< moDummyNeighbor<EOT> > & _sa_continue;
//! The cooling schedule
//moCoolingSchedule<EOT> & _cooling_schedule;
//! Initial temperature
//double _initial_temperature;
//! A EOT replacor //! A EOT replacor
eoReplacement < EOT > & _replacor; eoReplacement < EOT > & _replacor;
//! A EOT population continuator
eoContinue < EOT > & _pop_continuator;
//! A D continuator that always return true
edoDummyContinue<D> _dummy_continue;
//! A D continuator
edoContinue < D > & _distribution_continuator;
}; };
#endif // !_edoEDA_h #endif // !_edoEDA_h

68
edo/src/edoEstimatorNormalMono.h
View file

@ -42,57 +42,57 @@ public:
class Variance class Variance
{ {
public: public:
Variance() : _sumvar(0){} Variance() : _sumvar(0){}
void update(AtomType v) void update(AtomType v)
{ {
_n++; _n++;
AtomType d = v - _mean; AtomType d = v - _mean;
_mean += 1 / _n * d; _mean += 1 / _n * d;
_sumvar += (_n - 1) / _n * d * d; _sumvar += (_n - 1) / _n * d * d;
} }
AtomType get_mean() const {return _mean;} AtomType get_mean() const {return _mean;}
AtomType get_var() const {return _sumvar / (_n - 1);} AtomType get_var() const {return _sumvar / (_n - 1);}
AtomType get_std() const {return sqrt( get_var() );} AtomType get_std() const {return sqrt( get_var() );}
private: private:
AtomType _n; AtomType _n;
AtomType _mean; AtomType _mean;
AtomType _sumvar; AtomType _sumvar;
}; };
public: public:
edoNormalMono< EOT > operator()(eoPop<EOT>& pop) edoNormalMono< 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);
std::vector< Variance > var( dimsize ); std::vector< Variance > var( dimsize );
for (unsigned int i = 0; i < popsize; ++i) for (unsigned int i = 0; i < popsize; ++i)
{ {
for (unsigned int d = 0; d < dimsize; ++d) for (unsigned int d = 0; d < dimsize; ++d)
{ {
var[d].update( pop[i][d] ); var[d].update( pop[i][d] );
} }
} }
EOT mean( dimsize ); EOT mean( dimsize );
EOT variance( dimsize ); EOT variance( dimsize );
for (unsigned int d = 0; d < dimsize; ++d) for (unsigned int d = 0; d < dimsize; ++d)
{ {
mean[d] = var[d].get_mean(); mean[d] = var[d].get_mean();
variance[d] = var[d].get_var(); variance[d] = var[d].get_var();
} }
return edoNormalMono< EOT >( mean, variance ); return edoNormalMono< EOT >( mean, variance );
} }
}; };

47
edo/src/edoRepairer.h Normal file
View file

@ -0,0 +1,47 @@
/*
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) 2011 Thales group
*/
/*
Authors:
Johann Dréo <johann.dreo@thalesgroup.com>
Pierre Savéant <pierre.saveant@thalesgroup.com>
*/
#ifndef _edoRepairer_h
#define _edoRepairer_h
#include <eoFunctor.h>
/** The interface of a set of classes that modifies an unfeasible candidate
* solution so as to respect a given set of constraints and thus make a feasible
* solution.
*
* @ingroup Repairers
*/
template < typename EOT >
class edoRepairer : public eoUF< EOT&, void >
{
public:
// virtual void operator()( EOT& ) = 0 (provided by eoUF< A1, R >)
virtual void operator()( EOT& ) {}
};
#endif // !_edoRepairer_h

115
edo/src/edoRepairerDispatcher.h Normal file
View file

@ -0,0 +1,115 @@
/*
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) 2011 Thales group
*/
/*
Authors:
Johann Dréo <johann.dreo@thalesgroup.com>
Pierre Savéant <pierre.saveant@thalesgroup.com>
*/
#ifndef _edoRepairerDispatcher_h
#define _edoRepairerDispatcher_h
#include <vector>
#include <set>
#include <utility>
#include "edoRepairer.h"
/** Repair a candidate solution by sequentially applying several repairers on
* subparts of the solution (subparts being defined by the corresponding set
* of indexes).
*
* Only work on EOT that implements the "push_back( EOT::AtomType )" and
* "operator[](uint)" and "at(uint)" methods.
*
* Expects _addresses_ of the repairer operators.
*
* @example t-dispatcher-round.cpp
*
* @ingroup Repairers
*/
template < typename EOT >
class edoRepairerDispatcher
: public edoRepairer<EOT>,
std::vector<
std::pair< std::set< unsigned int >, edoRepairer< EOT >* >
>
{
public:
//! Empty constructor
edoRepairerDispatcher() :
std::vector<
std::pair< std::set< unsigned int >, edoRepairer< EOT >* >
>()
{}
//! Constructor with a single index set and repairer operator
edoRepairerDispatcher( std::set<unsigned int> idx, edoRepairer<EOT>* op ) :
std::vector<
std::pair< std::set< unsigned int >, edoRepairer< EOT >* >
>()
{
this->add( idx, op );
}
//! Add more indexes set and their corresponding repairer operator address to the list
void add( std::set<unsigned int> idx, edoRepairer<EOT>* op )
{
assert( idx.size() > 0 );
assert( op != NULL );
this->push_back( std::make_pair(idx, op) );
}
//! Repair a solution by calling several repair operator on subset of indexes
virtual void operator()( EOT& sol )
{
// ipair is an iterator that points on a pair
for( typename edoRepairerDispatcher<EOT>::iterator ipair = this->begin(); ipair != this->end(); ++ipair ) {
// a partial copy of the sol
EOT partsol;
// j is an iterator that points on an uint
for( std::set< unsigned int >::iterator j = ipair->first.begin(); j != ipair->first.end(); ++j ) {
partsol.push_back( sol.at(*j) );
} // for j
assert( partsol.size() > 0 );
// apply the repairer on the partial copy
// the repairer is a functor, thus second is callable
(*(ipair->second))( partsol );
{ // copy back the repaired partial solution to sol
// browse partsol with uint k, and the idx set with an iterator (std::set is an associative tab)
unsigned int k=0;
for( std::set< unsigned int >::iterator j = ipair->first.begin(); j != ipair->first.end(); ++j ) {
sol[ *j ] = partsol[ k ];
k++;
} // for j
} // context for k
} // for ipair
}
};
#endif // !_edoRepairerDispatcher_h

68
edo/src/edoRepairerRound.h Normal file
View file

@ -0,0 +1,68 @@
/*
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) 2011 Thales group
*/
/*
Authors:
Johann Dréo <johann.dreo@thalesgroup.com>
Pierre Savéant <pierre.saveant@thalesgroup.com>
*/
#ifndef _edoRepairerRound_h
#define _edoRepairerRound_h
#include <cmath>
#include "edoRepairer.h"
/**
*
* @ingroup Repairers
*/
template < typename EOT >
class edoRepairerFloor : public edoRepairer<EOT>
{
public:
virtual void operator()( EOT& sol )
{
for( unsigned int i=0; i < sol.size(); ++i ) {
sol[i] = floor( sol[i] );
}
}
};
/**
*
* @ingroup Repairers
*/
template < typename EOT >
class edoRepairerCeil : public edoRepairer<EOT>
{
public:
virtual void operator()( EOT& sol )
{
for( unsigned int i=0; i < sol.size(); ++i ) {
sol[i] = ceil( sol[i] );
}
}
};
#endif // !_edoRepairerRound_h

53
edo/src/edoSampler.h
View file

@ -30,7 +30,7 @@ Authors:
#include <eoFunctor.h> #include <eoFunctor.h>
#include "edoBounder.h" #include "edoRepairer.h"
#include "edoBounderNo.h" #include "edoBounderNo.h"
//! edoSampler< D > //! edoSampler< D >
@ -41,47 +41,34 @@ class edoSampler : public eoUF< D&, typename D::EOType >
public: public:
typedef typename D::EOType EOType; typedef typename D::EOType EOType;
edoSampler(edoBounder< EOType > & bounder) edoSampler(edoRepairer< EOType > & repairer)
: /*_dummy_bounder(),*/ _bounder(bounder) : _dummy_repairer(), _repairer(repairer)
{} {}
/*
edoSampler() edoSampler()
: _dummy_bounder(), _bounder( _dummy_bounder ) : _dummy_repairer(), _repairer( _dummy_repairer )
{} {}
*/
// virtual EOType operator()( D& ) = 0 (provided by eoUF< A1, R >) // virtual EOType operator()( D& ) = 0 (provided by eoUF< A1, R >)
EOType operator()( D& distrib ) EOType operator()( D& distrib )
{ {
unsigned int size = distrib.size(); unsigned int size = distrib.size();
assert(size > 0); assert(size > 0);
// Point we want to sample to get higher a set of points
// (coordinates in n dimension)
// x = {x1, x2, ..., xn}
// the sample method is implemented in the derivated class
EOType solution(sample(distrib));
//------------------------------------------------------------- // Now we are bounding the distribution thanks to min and max
// Point we want to sample to get higher a set of points // parameters.
// (coordinates in n dimension) _repairer(solution);
// x = {x1, x2, ..., xn}
// the sample method is implemented in the derivated class
//-------------------------------------------------------------
EOType solution(sample(distrib)); return solution;
//-------------------------------------------------------------
//-------------------------------------------------------------
// Now we are bounding the distribution thanks to min and max
// parameters.
//-------------------------------------------------------------
_bounder(solution);
//-------------------------------------------------------------
return solution;
} }
protected: protected:
@ -89,10 +76,10 @@ protected:
virtual EOType sample( D& ) = 0; virtual EOType sample( D& ) = 0;
private: private:
//edoBounderNo<EOType> _dummy_bounder; edoBounderNo<EOType> _dummy_repairer;
//! Bounder functor //! repairer functor
edoBounder< EOType > & _bounder; edoRepairer< EOType > & _repairer;
}; };

55
edo/src/edoSamplerNormalMono.h
View file

@ -39,52 +39,37 @@ Authors:
* This class uses the NormalMono distribution parameters (bounds) to return * This class uses the NormalMono distribution parameters (bounds) to return
* a random position used for population sampling. * a random position used for population sampling.
*/ */
template < typename EOT > template < typename EOT, typename D = edoNormalMono< EOT > >
class edoSamplerNormalMono : public edoSampler< edoNormalMono< EOT > > class edoSamplerNormalMono : public edoSampler< D >
{ {
public: public:
typedef typename EOT::AtomType AtomType; typedef typename EOT::AtomType AtomType;
edoSamplerNormalMono( edoBounder< EOT > & bounder ) edoSamplerNormalMono( edoRepairer<EOT> & repairer ) : edoSampler< D >( repairer) {}
: edoSampler< edoNormalMono< EOT > >( bounder )
{}
EOT sample( edoNormalMono< EOT >& distrib ) EOT sample( edoNormalMono< EOT >& distrib )
{ {
unsigned int size = distrib.size(); unsigned int size = distrib.size();
assert(size > 0); assert(size > 0);
// Point we want to sample to get higher a set of points
// (coordinates in n dimension)
// x = {x1, x2, ..., xn}
EOT solution;
// Sampling all dimensions
for (unsigned int i = 0; i < size; ++i)
{
AtomType mean = distrib.mean()[i];
AtomType variance = distrib.variance()[i];
AtomType random = rng.normal(mean, variance);
//------------------------------------------------------------- assert(variance >= 0);
// Point we want to sample to get higher a set of points
// (coordinates in n dimension)
// x = {x1, x2, ..., xn}
//-------------------------------------------------------------
EOT solution; solution.push_back(random);
}
//------------------------------------------------------------- return solution;
//-------------------------------------------------------------
// Sampling all dimensions
//-------------------------------------------------------------
for (unsigned int i = 0; i < size; ++i)
{
AtomType mean = distrib.mean()[i];
AtomType variance = distrib.variance()[i];
AtomType random = rng.normal(mean, variance);
assert(variance >= 0);
solution.push_back(random);
}
//-------------------------------------------------------------
return solution;
} }
}; };

164
edo/src/edoSamplerNormalMulti.h
View file

@ -34,142 +34,144 @@ Authors:
//! edoSamplerNormalMulti< EOT > //! edoSamplerNormalMulti< EOT >
template< class EOT > template< class EOT, typename D = edoNormalMulti< EOT > >
class edoSamplerNormalMulti : public edoSampler< edoNormalMulti< EOT > > class edoSamplerNormalMulti : public edoSampler< D >
{ {
public: public:
typedef typename EOT::AtomType AtomType; typedef typename EOT::AtomType AtomType;
edoSamplerNormalMulti( edoRepairer<EOT> & repairer ) : edoSampler< D >( repairer) {}
class Cholesky class Cholesky
{ {
public: public:
Cholesky( const ublas::symmetric_matrix< AtomType, ublas::lower >& V) Cholesky( const ublas::symmetric_matrix< AtomType, ublas::lower >& V)
{ {
unsigned int Vl = V.size1(); unsigned int Vl = V.size1();
assert(Vl > 0); assert(Vl > 0);
unsigned int Vc = V.size2(); unsigned int Vc = V.size2();
assert(Vc > 0); assert(Vc > 0);
assert( Vl == Vc ); assert( Vl == Vc );
_L.resize(Vl); _L.resize(Vl);
unsigned int i,j,k; unsigned int i,j,k;
// first column // first column
i=0; i=0;
// diagonal // diagonal
j=0; j=0;
_L(0, 0) = sqrt( V(0, 0) ); _L(0, 0) = sqrt( V(0, 0) );
// end of the column // end of the column
for ( j = 1; j < Vc; ++j ) for ( j = 1; j < Vc; ++j )
{ {
_L(j, 0) = V(0, j) / _L(0, 0); _L(j, 0) = V(0, j) / _L(0, 0);
} }
// end of the matrix // end of the matrix
for ( i = 1; i < Vl; ++i ) // each column for ( i = 1; i < Vl; ++i ) // each column
{ {
// diagonal // diagonal
double sum = 0.0; double sum = 0.0;
for ( k = 0; k < i; ++k) for ( k = 0; k < i; ++k)
{ {
sum += _L(i, k) * _L(i, k); sum += _L(i, k) * _L(i, k);
} }
_L(i,i) = sqrt( fabs( V(i,i) - sum) ); _L(i,i) = sqrt( fabs( V(i,i) - sum) );
for ( j = i + 1; j < Vl; ++j ) // rows for ( j = i + 1; j < Vl; ++j ) // rows
{ {
// one element // one element
sum = 0.0; sum = 0.0;
for ( k = 0; k < i; ++k ) for ( k = 0; k < i; ++k )
{ {
sum += _L(j, k) * _L(i, k); sum += _L(j, k) * _L(i, k);
} }
_L(j, i) = (V(j, i) - sum) / _L(i, i); _L(j, i) = (V(j, i) - sum) / _L(i, i);
} }
} }
} }
const ublas::symmetric_matrix< AtomType, ublas::lower >& get_L() const {return _L;} const ublas::symmetric_matrix< AtomType, ublas::lower >& get_L() const {return _L;}
private: private:
ublas::symmetric_matrix< AtomType, ublas::lower > _L; ublas::symmetric_matrix< AtomType, ublas::lower > _L;
}; };
edoSamplerNormalMulti( edoBounder< EOT > & bounder ) edoSamplerNormalMulti( edoBounder< EOT > & bounder )
: edoSampler< edoNormalMulti< EOT > >( bounder ) : edoSampler< edoNormalMulti< EOT > >( bounder )
{} {}
EOT sample( edoNormalMulti< EOT >& distrib ) EOT sample( edoNormalMulti< EOT >& distrib )
{ {
unsigned int size = distrib.size(); unsigned int size = distrib.size();
assert(size > 0); assert(size > 0);
//------------------------------------------------------------- //-------------------------------------------------------------
// Cholesky factorisation gererating matrix L from covariance // Cholesky factorisation gererating matrix L from covariance
// matrix V. // matrix V.
// We must use cholesky.get_L() to get the resulting matrix. // We must use cholesky.get_L() to get the resulting matrix.
// //
// L = cholesky decomposition of varcovar // L = cholesky decomposition of varcovar
//------------------------------------------------------------- //-------------------------------------------------------------
Cholesky cholesky( distrib.varcovar() ); Cholesky cholesky( distrib.varcovar() );
ublas::symmetric_matrix< AtomType, ublas::lower > L = cholesky.get_L(); ublas::symmetric_matrix< AtomType, ublas::lower > L = cholesky.get_L();
//------------------------------------------------------------- //-------------------------------------------------------------
//------------------------------------------------------------- //-------------------------------------------------------------
// T = vector of size elements drawn in N(0,1) rng.normal(1.0) // T = vector of size elements drawn in N(0,1) rng.normal(1.0)
//------------------------------------------------------------- //-------------------------------------------------------------
ublas::vector< AtomType > T( size ); ublas::vector< AtomType > T( size );
for ( unsigned int i = 0; i < size; ++i ) for ( unsigned int i = 0; i < size; ++i )
{ {
T( i ) = rng.normal( 1.0 ); T( i ) = rng.normal( 1.0 );
} }
//------------------------------------------------------------- //-------------------------------------------------------------
//------------------------------------------------------------- //-------------------------------------------------------------
// LT = prod( L, T ) // LT = prod( L, T )
//------------------------------------------------------------- //-------------------------------------------------------------
ublas::vector< AtomType > LT = ublas::prod( L, T ); ublas::vector< AtomType > LT = ublas::prod( L, T );
//------------------------------------------------------------- //-------------------------------------------------------------
//------------------------------------------------------------- //-------------------------------------------------------------
// solution = means + LT // solution = means + LT
//------------------------------------------------------------- //-------------------------------------------------------------
ublas::vector< AtomType > mean = distrib.mean(); ublas::vector< AtomType > mean = distrib.mean();
ublas::vector< AtomType > ublas_solution = mean + LT; ublas::vector< AtomType > ublas_solution = mean + LT;
EOT solution( size ); EOT solution( size );
std::copy( ublas_solution.begin(), ublas_solution.end(), solution.begin() ); std::copy( ublas_solution.begin(), ublas_solution.end(), solution.begin() );
//------------------------------------------------------------- //-------------------------------------------------------------
return solution; return solution;
} }
}; };

60
edo/src/edoSamplerUniform.h
View file

@ -38,58 +38,34 @@ Authors:
* This class uses the Uniform distribution parameters (bounds) to return * This class uses the Uniform distribution parameters (bounds) to return
* a random position used for population sampling. * a random position used for population sampling.
*/ */
template < typename EOT, class D=edoUniform<EOT> > // FIXME: D template name is there really used ?!? template < typename EOT, class D = edoUniform<EOT> >
class edoSamplerUniform : public edoSampler< edoUniform< EOT > > class edoSamplerUniform : public edoSampler< D >
{ {
public: public:
typedef D Distrib; typedef D Distrib;
edoSamplerUniform(edoBounder< EOT > & bounder) edoSamplerUniform( edoRepairer<EOT> & repairer ) : edoSampler< D >( repairer) {}
: edoSampler< edoUniform<EOT> >(bounder) // FIXME: Why D is not used here ?
{}
/*
edoSamplerUniform()
: edoSampler< edoUniform<EOT> >()
{}
*/
EOT sample( edoUniform< EOT >& distrib ) EOT sample( edoUniform< EOT >& distrib )
{ {
unsigned int size = distrib.size(); unsigned int size = distrib.size();
assert(size > 0); assert(size > 0);
// Point we want to sample to get higher a set of points
// (coordinates in n dimension)
// x = {x1, x2, ..., xn}
EOT solution;
//------------------------------------------------------------- // Sampling all dimensions
// Point we want to sample to get higher a set of points for (unsigned int i = 0; i < size; ++i)
// (coordinates in n dimension) {
// x = {x1, x2, ..., xn} double min = distrib.min()[i];
//------------------------------------------------------------- double max = distrib.max()[i];
double random = rng.uniform(min, max);
solution.push_back(random);
}
EOT solution; return solution;
//-------------------------------------------------------------
//-------------------------------------------------------------
// Sampling all dimensions
//-------------------------------------------------------------
for (unsigned int i = 0; i < size; ++i)
{
double min = distrib.min()[i];
double max = distrib.max()[i];
double random = rng.uniform(min, max);
assert(min <= random && random <= max);
solution.push_back(random);
}
//-------------------------------------------------------------
return solution;
} }
}; };

2
edo/src/edoUniform.h
View file

@ -38,7 +38,7 @@ class edoUniform : public edoDistrib< EOT >, public edoVectorBounds< EOT >
{ {
public: public:
edoUniform(EOT min, EOT max) edoUniform(EOT min, EOT max)
: edoVectorBounds< EOT >(min, max) : edoVectorBounds< EOT >(min, max)
{} {}
}; };

10
edo/src/edoVectorBounds.h
View file

@ -35,10 +35,10 @@ class edoVectorBounds
{ {
public: public:
edoVectorBounds(EOT min, EOT max) edoVectorBounds(EOT min, EOT max)
: _min(min), _max(max) : _min(min), _max(max)
{ {
assert(_min.size() > 0); assert(_min.size() > 0);
assert(_min.size() == _max.size()); assert(_min.size() == _max.size());
} }
EOT min(){return _min;} EOT min(){return _min;}
@ -46,8 +46,8 @@ public:
unsigned int size() unsigned int size()
{ {
assert(_min.size() == _max.size()); assert(_min.size() == _max.size());
return _min.size(); return _min.size();
} }
private: private:

1
edo/test/CMakeLists.txt
View file

@ -38,6 +38,7 @@ SET(SOURCES
t-bounderno t-bounderno
t-uniform t-uniform
t-continue t-continue
t-dispatcher-round
) )
FOREACH(current ${SOURCES}) FOREACH(current ${SOURCES})

62
edo/test/t-dispatcher-round.cpp Normal file
View file

@ -0,0 +1,62 @@
/*
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>
Pierre Savéant <pierre.saveant@thalesgroup.com>
*/
#include <eo>
#include <edo>
#include <es.h>
typedef eoReal< eoMinimizingFitness > EOT;
int main(void)
{
EOT sol;
sol.push_back(1.1);
sol.push_back(1.1);
sol.push_back(3.9);
sol.push_back(3.9);
// we expect {1,2,3,4}
edoRepairer<EOT>* rep1 = new edoRepairerFloor<EOT>();
edoRepairer<EOT>* rep2 = new edoRepairerCeil<EOT>();
std::set<unsigned int> indexes1;
indexes1.insert(0);
indexes1.insert(2);
std::set<unsigned int> indexes2;
indexes2.insert(1);
indexes2.insert(3);
edoRepairerDispatcher<EOT> repare( indexes1, rep1 );
repare.add( indexes2, rep2 );
repare(sol);
std::cout << sol << std::endl;
return 0;
}

7
eo/CMakeLists.txt
View file

@ -1,3 +1,4 @@
###################################################################################### ######################################################################################
### 0) If you want to set your variables in eo-conf.cmake and avoid the cmd line ### 0) If you want to set your variables in eo-conf.cmake and avoid the cmd line
###################################################################################### ######################################################################################
@ -14,6 +15,9 @@ INCLUDE(eo-conf.cmake OPTIONAL)
# set the project name and other variables # set the project name and other variables
PROJECT(EO) PROJECT(EO)
# CMake > 2.8 is needed, because of the FindOpenMP feature
cmake_minimum_required(VERSION 2.8)
#SET(PROJECT_VERSION_MAJOR 1) #SET(PROJECT_VERSION_MAJOR 1)
#SET(PROJECT_VERSION_MINOR 1) #SET(PROJECT_VERSION_MINOR 1)
#SET(PROJECT_VERSION_PATCH 1) #SET(PROJECT_VERSION_PATCH 1)
@ -26,9 +30,6 @@ SET(PACKAGE_NAME "Evolving Objects" CACHE STRING "Package name" FORCE)
SET(PACKAGE_STRING "${PACKAGE_NAME} ${PACKAGE_VERSION}"CACHE STRING "Package string full name" FORCE) SET(PACKAGE_STRING "${PACKAGE_NAME} ${PACKAGE_VERSION}"CACHE STRING "Package string full name" FORCE)
SET(PACKAGE_TARNAME "eo" CACHE STRING "Package tar name" FORCE) SET(PACKAGE_TARNAME "eo" CACHE STRING "Package tar name" FORCE)
# check cmake version compatibility
CMAKE_MINIMUM_REQUIRED(VERSION 2.6)
# regular expression checking # regular expression checking
INCLUDE_REGULAR_EXPRESSION("^.*$" "^$") INCLUDE_REGULAR_EXPRESSION("^.*$" "^$")

3
website/index.html
View file

@ -42,7 +42,8 @@
<li><a href="http://sourceforge.net/project/showfiles.php?group_id=9775">Download</a></li> <li><a href="http://sourceforge.net/project/showfiles.php?group_id=9775">Download</a></li>
<li><a href="http://eodev.sourceforge.net/eo/tutorial/html/eoTutorial.html">Tutorial</a></li> <li><a href="http://eodev.sourceforge.net/eo/tutorial/html/eoTutorial.html">Tutorial</a></li>
<li><a href="https://sourceforge.net/apps/trac/eodev/wiki/faq">FAQ</a></li> <li><a href="https://sourceforge.net/apps/trac/eodev/wiki/faq">FAQ</a></li>
<li><a href="http://eodev.sourceforge.net/eo/doc/html/index.html">API documentation</a></li> <li><a href="http://eodev.sourceforge.net/eo/doc/html/index.html">EO documentation</a></li>
<li><a href="http://eodev.sourceforge.net/edo/doc/html/index.html">EDO documentation</a></li>
<li><a href="http://sourceforge.net/project/?group_id=9775">Project page</a></li> <li><a href="http://sourceforge.net/project/?group_id=9775">Project page</a></li>
<li><a href="https://lists.sourceforge.net/lists/listinfo/eodev-main">Contact us</a></li> <li><a href="https://lists.sourceforge.net/lists/listinfo/eodev-main">Contact us</a></li>
<!--<li><a href="http://chat.jabberfr.org/muckl_int/index.php?room=eo">Chat with us</a></li>--> <!--<li><a href="http://chat.jabberfr.org/muckl_int/index.php?room=eo">Chat with us</a></li>-->