nojhan/paradiseo
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

4
edo/src/edo
View file

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

9
edo/src/edoAlgo.h
View file

@ -31,14 +31,19 @@ Authors:
#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 >
class edoAlgo : public eoAlgo< typename D::EOType >
{
//! Alias for the type
typedef typename D::EOType EOT;
// virtual R operator()(A1) = 0; (defined in eoUF)
public:
virtual ~edoAlgo(){}
};

23
edo/src/edoBounder.h
View file

@ -28,19 +28,26 @@ Authors:
#ifndef _edoBounder_h
#define _edoBounder_h
#include <eoFunctor.h>
//! edoBounder< EOT >
#include <edoRepairer.h>
/** 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 >
class edoBounder : public eoUF< EOT&, void >
class edoBounder : public edoRepairer< EOT >
{
public:
edoBounder( EOT min = EOT(1, 0), EOT max = EOT(1, 0) )
: _min(min), _max(max)
edoBounder()
{}
edoBounder( EOT min/* = EOT(1, 0)*/, EOT max/* = EOT(1, 1)*/ )
: _min(min), _max(max)
{
assert(_min.size() > 0);
assert(_min.size() == _max.size());
assert(_min.size() > 0);
assert(_min.size() == _max.size());
}
// 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"
//! edoBounderBound< EOT >
/** A bounder that correct an incorrect variable by setting it to the min/max
*
* @ingroup Repairers
*/
template < typename EOT >
class edoBounderBound : public edoBounder< EOT >
{
public:
edoBounderBound( EOT min, EOT max )
: edoBounder< EOT >( min, max )
: edoBounder< EOT >( min, max )
{}
void operator()( EOT& x )
{
unsigned int size = x.size();
assert(size > 0);
unsigned int size = x.size();
assert(size > 0);
for (unsigned int d = 0; d < size; ++d) // browse all dimensions
{
if (x[d] < this->min()[d])
{
x[d] = this->min()[d];
continue;
}
for (unsigned int d = 0; d < size; ++d) // browse all dimensions
{
if (x[d] < this->min()[d])
{
x[d] = this->min()[d];
continue;
}
if (x[d] > this->max()[d])
{
x[d] = this->max()[d];
}
}
if (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"
//! edoBounderNo< EOT >
/** A bounder that does nothing.
*
* @ingroup Repairers
*/
template < typename EOT >
class edoBounderNo : public edoBounder< EOT >
{

29
edo/src/edoBounderRng.h
View file

@ -30,31 +30,34 @@ Authors:
#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 >
class edoBounderRng : public edoBounder< EOT >
{
public:
edoBounderRng( EOT min, EOT max, eoRndGenerator< double > & rng )
: edoBounder< EOT >( min, max ), _rng(rng)
: edoBounder< EOT >( min, max ), _rng(rng)
{}
void operator()( EOT& x )
{
unsigned int size = x.size();
assert(size > 0);
unsigned int size = x.size();
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])
{
x[d] = _rng();
}
}
if (x[d] < this->min()[d] || x[d] > this->max()[d])
{
x[d] = _rng();
}
}
}
private:

31
edo/src/edoBounderUniform.h
View file

@ -29,28 +29,35 @@ Authors:
#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 >
class edoBounderUniform : public edoBounder< EOT >
{
public:
edoBounderUniform( EOT min, EOT max )
: edoBounder< EOT >( min, max )
{}
: edoBounder< EOT >( min, max )
{
}
void operator()( EOT& sol )
{
unsigned int size = sol.size();
assert(size > 0);
assert( this->min().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]) {
// use EO's global "rng"
sol[d] = rng.uniform( this->min()[d], this->max()[d] );
}
} // for d in size
unsigned int size = sol.size();
for (unsigned int d = 0; d < size; ++d) {
if ( sol[d] < this->min()[d] || sol[d] > this->max()[d]) {
// 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
/*!
All the boxes used by a EDASA need to be given.
Takes algo operators, all are mandatory
\param selector Population Selector
\param estimator Distribution Estimator
\param selectone SelectOne
\param modifier Distribution Modifier
\param sampler Distribution Sampler
\param pop_continue Population Continuator
\param distribution_continue Distribution Continuator
\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
\param evaluation Evaluate a population
\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
\param distribution_continuator Stopping criterion based on the distribution features
*/
edoEDA (eoSelect< EOT > & selector,
edoEstimator< D > & estimator,
eoSelectOne< EOT > & selectone,
edoModifierMass< D > & modifier,
edoSampler< D > & sampler,
eoContinue< EOT > & pop_continue,
edoContinue< D > & distribution_continue,
eoEvalFunc < EOT > & evaluation,
//moContinuator< moDummyNeighbor<EOT> > & sa_continue,
//moCoolingSchedule<EOT> & cooling_schedule,
//double initial_temperature,
eoReplacement< EOT > & replacor
)
: _selector(selector),
_estimator(estimator),
_selectone(selectone),
_modifier(modifier),
_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)
edoEDA (
eoPopEvalFunc < EOT > & evaluator,
eoSelect< EOT > & selector,
edoEstimator< D > & estimator,
edoSampler< D > & sampler,
eoReplacement< EOT > & replacor,
eoContinue< EOT > & pop_continuator,
edoContinue< D > & distribution_continuator
) :
_evaluator(evaluator),
_selector(selector),
_estimator(estimator),
_sampler(sampler),
_replacor(replacor),
_pop_continuator(pop_continuator),
_dummy_continue(),
_distribution_continuator(distribution_continuator)
{}
//! 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.
\return TRUE.
\param evaluation Evaluate a population
\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)
{
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 ???
//-------------------------------------------------------------
// Estimating a first time the distribution parameter thanks
// to population.
//-------------------------------------------------------------
// (2) Estimation of the distribution parameters
distrib = _estimator(selected_pop);
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();
assert(size > 0);
// (4) Evaluate new solutions
_evaluator( pop, current_pop );
//-------------------------------------------------------------
// (5) Replace old solutions by new ones
_replacor(pop, current_pop); // e.g. copy current_pop in pop
do
{
//-------------------------------------------------------------
// (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 );
}
} while( _distribution_continuator( distrib ) && _pop_continuator( pop ) );
} // operator()
private:
//! A full evaluation function.
eoPopEvalFunc < EOT > & _evaluator;
//! A EOT selector
eoSelect < EOT > & _selector;
//! A EOT estimator. It is going to estimate distribution parameters.
edoEstimator< D > & _estimator;
//! SelectOne
eoSelectOne< EOT > & _selectone;
//! A D modifier
edoModifierMass< D > & _modifier;
//! A 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
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

68
edo/src/edoEstimatorNormalMono.h
View file

@ -42,57 +42,57 @@ public:
class Variance
{
public:
Variance() : _sumvar(0){}
Variance() : _sumvar(0){}
void update(AtomType v)
{
_n++;
void update(AtomType v)
{
_n++;
AtomType d = v - _mean;
AtomType d = v - _mean;
_mean += 1 / _n * d;
_sumvar += (_n - 1) / _n * d * d;
}
_mean += 1 / _n * d;
_sumvar += (_n - 1) / _n * d * d;
}
AtomType get_mean() const {return _mean;}
AtomType get_var() const {return _sumvar / (_n - 1);}
AtomType get_std() const {return sqrt( get_var() );}
AtomType get_mean() const {return _mean;}
AtomType get_var() const {return _sumvar / (_n - 1);}
AtomType get_std() const {return sqrt( get_var() );}
private:
AtomType _n;
AtomType _mean;
AtomType _sumvar;
AtomType _n;
AtomType _mean;
AtomType _sumvar;
};
public:
edoNormalMono< 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);
std::vector< Variance > var( dimsize );
std::vector< Variance > var( dimsize );
for (unsigned int i = 0; i < popsize; ++i)
{
for (unsigned int d = 0; d < dimsize; ++d)
{
var[d].update( pop[i][d] );
}
}
for (unsigned int i = 0; i < popsize; ++i)
{
for (unsigned int d = 0; d < dimsize; ++d)
{
var[d].update( pop[i][d] );
}
}
EOT mean( dimsize );
EOT variance( dimsize );
EOT mean( dimsize );
EOT variance( dimsize );
for (unsigned int d = 0; d < dimsize; ++d)
{
mean[d] = var[d].get_mean();
variance[d] = var[d].get_var();
}
for (unsigned int d = 0; d < dimsize; ++d)
{
mean[d] = var[d].get_mean();
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 "edoBounder.h"
#include "edoRepairer.h"
#include "edoBounderNo.h"
//! edoSampler< D >
@ -41,47 +41,34 @@ class edoSampler : public eoUF< D&, typename D::EOType >
public:
typedef typename D::EOType EOType;
edoSampler(edoBounder< EOType > & bounder)
: /*_dummy_bounder(),*/ _bounder(bounder)
edoSampler(edoRepairer< EOType > & repairer)
: _dummy_repairer(), _repairer(repairer)
{}
/*
edoSampler()
: _dummy_bounder(), _bounder( _dummy_bounder )
: _dummy_repairer(), _repairer( _dummy_repairer )
{}
*/
// virtual EOType operator()( D& ) = 0 (provided by eoUF< A1, R >)
EOType operator()( D& distrib )
{
unsigned int size = distrib.size();
assert(size > 0);
unsigned int size = distrib.size();
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));
//-------------------------------------------------------------
// 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
//-------------------------------------------------------------
// Now we are bounding the distribution thanks to min and max
// parameters.
_repairer(solution);
EOType solution(sample(distrib));
//-------------------------------------------------------------
//-------------------------------------------------------------
// Now we are bounding the distribution thanks to min and max
// parameters.
//-------------------------------------------------------------
_bounder(solution);
//-------------------------------------------------------------
return solution;
return solution;
}
protected:
@ -89,10 +76,10 @@ protected:
virtual EOType sample( D& ) = 0;
private:
//edoBounderNo<EOType> _dummy_bounder;
edoBounderNo<EOType> _dummy_repairer;
//! Bounder functor
edoBounder< EOType > & _bounder;
//! repairer functor
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
* a random position used for population sampling.
*/
template < typename EOT >
class edoSamplerNormalMono : public edoSampler< edoNormalMono< EOT > >
template < typename EOT, typename D = edoNormalMono< EOT > >
class edoSamplerNormalMono : public edoSampler< D >
{
public:
typedef typename EOT::AtomType AtomType;
edoSamplerNormalMono( edoBounder< EOT > & bounder )
: edoSampler< edoNormalMono< EOT > >( bounder )
{}
edoSamplerNormalMono( edoRepairer<EOT> & repairer ) : edoSampler< D >( repairer) {}
EOT sample( edoNormalMono< EOT >& distrib )
{
unsigned int size = distrib.size();
assert(size > 0);
unsigned int size = distrib.size();
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);
//-------------------------------------------------------------
// Point we want to sample to get higher a set of points
// (coordinates in n dimension)
// x = {x1, x2, ..., xn}
//-------------------------------------------------------------
assert(variance >= 0);
EOT solution;
solution.push_back(random);
}
//-------------------------------------------------------------
//-------------------------------------------------------------
// 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;
return solution;
}
};

164
edo/src/edoSamplerNormalMulti.h
View file

@ -34,142 +34,144 @@ Authors:
//! edoSamplerNormalMulti< EOT >
template< class EOT >
class edoSamplerNormalMulti : public edoSampler< edoNormalMulti< EOT > >
template< class EOT, typename D = edoNormalMulti< EOT > >
class edoSamplerNormalMulti : public edoSampler< D >
{
public:
typedef typename EOT::AtomType AtomType;
edoSamplerNormalMulti( edoRepairer<EOT> & repairer ) : edoSampler< D >( repairer) {}
class Cholesky
{
public:
Cholesky( const ublas::symmetric_matrix< AtomType, ublas::lower >& V)
{
unsigned int Vl = V.size1();
Cholesky( const ublas::symmetric_matrix< AtomType, ublas::lower >& V)
{
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
i=0;
// first column
i=0;
// diagonal
j=0;
_L(0, 0) = sqrt( V(0, 0) );
// diagonal
j=0;
_L(0, 0) = sqrt( V(0, 0) );
// end of the column
for ( j = 1; j < Vc; ++j )
{
_L(j, 0) = V(0, j) / _L(0, 0);
}
// end of the column
for ( j = 1; j < Vc; ++j )
{
_L(j, 0) = V(0, j) / _L(0, 0);
}
// end of the matrix
for ( i = 1; i < Vl; ++i ) // each column
{
// end of the matrix
for ( i = 1; i < Vl; ++i ) // each column
{
// diagonal
double sum = 0.0;
// diagonal
double sum = 0.0;
for ( k = 0; k < i; ++k)
{
sum += _L(i, k) * _L(i, k);
}
for ( k = 0; k < 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
{
// one element
sum = 0.0;
for ( j = i + 1; j < Vl; ++j ) // rows
{
// one element
sum = 0.0;
for ( k = 0; k < i; ++k )
{
sum += _L(j, k) * _L(i, k);
}
for ( k = 0; k < 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:
ublas::symmetric_matrix< AtomType, ublas::lower > _L;
ublas::symmetric_matrix< AtomType, ublas::lower > _L;
};
edoSamplerNormalMulti( edoBounder< EOT > & bounder )
: edoSampler< edoNormalMulti< EOT > >( bounder )
: edoSampler< edoNormalMulti< EOT > >( bounder )
{}
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
// matrix V.
// We must use cholesky.get_L() to get the resulting matrix.
//
// L = cholesky decomposition of varcovar
//-------------------------------------------------------------
//-------------------------------------------------------------
// Cholesky factorisation gererating matrix L from covariance
// matrix V.
// We must use cholesky.get_L() to get the resulting matrix.
//
// L = cholesky decomposition of varcovar
//-------------------------------------------------------------
Cholesky cholesky( distrib.varcovar() );
ublas::symmetric_matrix< AtomType, ublas::lower > L = cholesky.get_L();
Cholesky cholesky( distrib.varcovar() );
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 )
{
T( i ) = rng.normal( 1.0 );
}
for ( unsigned int i = 0; i < size; ++i )
{
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
* a random position used for population sampling.
*/
template < typename EOT, class D=edoUniform<EOT> > // FIXME: D template name is there really used ?!?
class edoSamplerUniform : public edoSampler< edoUniform< EOT > >
template < typename EOT, class D = edoUniform<EOT> >
class edoSamplerUniform : public edoSampler< D >
{
public:
typedef D Distrib;
edoSamplerUniform(edoBounder< EOT > & bounder)
: edoSampler< edoUniform<EOT> >(bounder) // FIXME: Why D is not used here ?
{}
/*
edoSamplerUniform()
: edoSampler< edoUniform<EOT> >()
{}
*/
edoSamplerUniform( edoRepairer<EOT> & repairer ) : edoSampler< D >( repairer) {}
EOT sample( edoUniform< EOT >& distrib )
{
unsigned int size = distrib.size();
assert(size > 0);
unsigned int size = distrib.size();
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;
//-------------------------------------------------------------
// Point we want to sample to get higher a set of points
// (coordinates in n dimension)
// x = {x1, x2, ..., xn}
//-------------------------------------------------------------
// 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);
solution.push_back(random);
}
EOT 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;
return solution;
}
};

2
edo/src/edoUniform.h
View file

@ -38,7 +38,7 @@ class edoUniform : public edoDistrib< EOT >, public edoVectorBounds< EOT >
{
public:
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:
edoVectorBounds(EOT min, EOT max)
: _min(min), _max(max)
: _min(min), _max(max)
{
assert(_min.size() > 0);
assert(_min.size() == _max.size());
assert(_min.size() > 0);
assert(_min.size() == _max.size());
}
EOT min(){return _min;}
@ -46,8 +46,8 @@ public:
unsigned int size()
{
assert(_min.size() == _max.size());
return _min.size();
assert(_min.size() == _max.size());
return _min.size();
}
private: