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

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

Browse source
This commit is contained in:
nojhan 2011-10-06 16:44:49 +02:00
commit 12e003b12d
23 changed files with 576 additions and 279 deletions
Download patch file Download diff file Expand all files Collapse all files

1
edo/CMakeLists.txt
View file

@ -42,7 +42,6 @@ INCLUDE_DIRECTORIES(
LINK_DIRECTORIES(
${EO_LIBRARY_DIRS}
${MO_LIBRARY_DIRS}
)
######################################################################################

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

@ -24,4 +24,4 @@ FILE(GLOB SOURCES *.cpp)
SET(EXECUTABLE_OUTPUT_PATH ${EDO_BINARY_DIR})
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})

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"

12
edo/src/edoBounder.h
View file

@ -28,18 +28,22 @@ Authors:
#ifndef _edoBounder_h
#define _edoBounder_h
#include <eoFunctor.h>
#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 Bounders
* @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) )
edoBounder()
{}
edoBounder( EOT min/* = EOT(1, 0)*/, EOT max/* = EOT(1, 1)*/ )
: _min(min), _max(max)
{
assert(_min.size() > 0);

2
edo/src/edoBounderBound.h
View file

@ -32,7 +32,7 @@ Authors:
/** A bounder that correct an incorrect variable by setting it to the min/max
*
* @ingroup Bounders
* @ingroup Repairers
*/
template < typename EOT >
class edoBounderBound : public edoBounder< EOT >

2
edo/src/edoBounderNo.h
View file

@ -32,7 +32,7 @@ Authors:
/** A bounder that does nothing.
*
* @ingroup Bounders
* @ingroup Repairers
*/
template < typename EOT >
class edoBounderNo : public edoBounder< EOT >

2
edo/src/edoBounderRng.h
View file

@ -33,7 +33,7 @@ Authors:
/** A bounder that randomly draw new values for variables going out bounds,
* using an eoRng to do so.
*
* @ingroup Bounders
* @ingroup Repairers
*/
template < typename EOT >
class edoBounderRng : public edoBounder< EOT >

12
edo/src/edoBounderUniform.h
View file

@ -32,7 +32,7 @@ Authors:
/** A bounder that randomly draw new values for variables going out bounds,
* in a given uniform distribution.
*
* @ingroup Bounders
* @ingroup Repairers
*/
template < typename EOT >
class edoBounderUniform : public edoBounder< EOT >
@ -40,13 +40,17 @@ class edoBounderUniform : public edoBounder< EOT >
public:
edoBounderUniform( EOT min, EOT 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 );
assert( sol.size() > 0);
unsigned int size = sol.size();
for (unsigned int d = 0; d < size; ++d) {
if ( sol[d] < this->min()[d] || sol[d] > this->max()[d]) {

79
edo/src/edoEDA.h
View file

@ -60,32 +60,63 @@ public:
/*!
Takes algo operators, all are mandatory
\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
\param evaluation Evaluate a population
\param replacor Replace old solutions by new ones
*/
edoEDA (
eoSelect< EOT > & selector,
edoEstimator< D > & estimator,
edoSampler< D > & sampler,
eoContinue< EOT > & pop_continuator,
edoContinue< D > & distribution_continuator,
eoPopEvalFunc < EOT > & evaluator,
eoReplacement< EOT > & replacor
)
: _selector(selector),
_estimator(estimator),
_sampler(sampler),
_pop_continuator(pop_continuator),
_distribution_continuator(distribution_continuator),
_evaluator(evaluator),
_replacor(replacor)
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)
{}
//! edoEDA constructor without an edoContinue
/*!
Takes algo operators, all are mandatory
\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
*
@ -135,6 +166,9 @@ public:
private:
//! A full evaluation function.
eoPopEvalFunc < EOT > & _evaluator;
//! A EOT selector
eoSelect < EOT > & _selector;
@ -144,17 +178,18 @@ private:
//! A D sampler
edoSampler< D > & _sampler;
//! 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;
//! A full evaluation function.
eoPopEvalFunc < EOT > & _evaluator;
//! A EOT replacor
eoReplacement < EOT > & _replacor;
};
#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:

1
edo/test/CMakeLists.txt
View file

@ -38,6 +38,7 @@ SET(SOURCES
t-bounderno
t-uniform
t-continue
t-dispatcher-round
)
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;
}

15
eo/src/utils/eoParser.cpp
View file

@ -35,16 +35,11 @@
#include <cctype>
#include <utils/compatibility.h>
#include <utils/eoParser.h>
#include <utils/eoLogger.h>
using namespace std;
void eoWarning(std::string str)
{
cout << str << '\n';
}
std::ostream& printSectionHeader(std::ostream& os, std::string section)
{
if (section == "")
@ -117,6 +112,11 @@ eoParser::eoParser ( unsigned _argc, char **_argv , string _programDescription,
}
std::string eoParser::get( const std::string & name) const
{
return getParamWithLongName( name )->getValue();
}
eoParam * eoParser::getParamWithLongName(const std::string& _name) const
{
@ -130,7 +130,6 @@ eoParam * eoParser::getParamWithLongName(const std::string& _name) const
}
void eoParser::processParam(eoParam& param, std::string section)
{
// this param enters the parser: add the prefix to the long name
@ -214,7 +213,7 @@ void eoParser::readFrom(istream& is)
{
if (str.size() < 2)
{
eoWarning("Missing parameter");
eo::log << eo::warnings << "Missing parameter" << std::endl;
needHelp.value() = true;
return;
}

9
eo/src/utils/eoParser.h
View file

@ -97,6 +97,11 @@ private :
This class is persistent, so it can be stored and reloaded to restore
parameter settings.
Parameters can be read from argv, strings or streams, and must be specified
using the following convention: --name=value or -n=value
You should not use space as a separator between the parameter and its value.
@ingroup Parameters
*/
class eoParser : public eoParameterLoader, public eoObject, public eoPersistent
@ -156,6 +161,10 @@ public:
virtual bool isItThere(eoParam& _param) const
{ return getValue(_param).first; }
std::string get( const std::string & name) const;
/**
* get a handle on a param from its longName
*