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

refactored vectors repairers that are using a function in a more generic way, added a binary function wrapper for vectors repairers, with the modulus function as an example

Browse source
This commit is contained in:
nojhan 2011-11-08 17:55:01 +01:00
commit 4d45970767
6 changed files with 213 additions and 17 deletions
Download patch file Download diff file Expand all files Collapse all files

1
edo/src/edo
View file

@ -59,6 +59,7 @@ Authors:
#include "edoRepairer.h"
#include "edoRepairerDispatcher.h"
#include "edoRepairerRound.h"
#include "edoRepairerModulo.h"
#include "edoBounder.h"
#include "edoBounderNo.h"
#include "edoBounderBound.h"

98
edo/src/edoRepairerApply.h Normal file
View file

@ -0,0 +1,98 @@
/*
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>
*/
#ifndef _edoRepairerApply_h
#define _edoRepairerApply_h
#include <algorithm>
#include "edoRepairer.h"
template < typename EOT, typename F = typename EOT::AtomType(typename EOT::AtomType) >
class edoRepairerApply : public edoRepairer<EOT>
{
public:
edoRepairerApply( F function ) : _function(function) {}
protected:
F * _function;
};
/** Apply an arbitrary unary function as a repairer on each item of the solution
*
* By default, the signature of the expected function is "EOT::AtomType(EOT::AtomType)"
*
* @ingroup Repairers
*/
template < typename EOT, typename F = typename EOT::AtomType(typename EOT::AtomType)>
class edoRepairerApplyUnary : public edoRepairerApply<EOT,F>
{
public:
edoRepairerApplyUnary( F function ) : edoRepairerApply<EOT,F>(function) {}
virtual void operator()( EOT& sol )
{
std::transform( sol.begin(), sol.end(), sol.begin(), *(this->_function) );
}
};
/** Apply an arbitrary binary function as a repairer on each item of the solution,
* the second argument of the function being fixed and given at instanciation.
*
* @see edoRepairerApplyUnary
*
* @ingroup Repairers
*/
template < typename EOT, typename F = typename EOT::AtomType(typename EOT::AtomType, typename EOT::AtomType)>
class edoRepairerApplyBinary : public edoRepairerApply<EOT,F>
{
public:
typedef typename EOT::AtomType ArgType;
edoRepairerApplyBinary(
F function,
ArgType arg
) : edoRepairerApply<EOT,F>(function), _arg(arg) {}
virtual void operator()( EOT& sol )
{
// call the binary function on each item
// TODO find a way to use std::transform here? Or would it be too bloated?
for(typename EOT::iterator it = sol.begin(); it != sol.end(); ++it ) {
*it = (*(this->_function))( *it, _arg );
}
}
protected:
ArgType _arg;
};
#endif // !_edoRepairerApply_h

47
edo/src/edoRepairerModulo.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>
*/
#ifndef _edoRepairerModulo_h
#define _edoRepairerModulo_h
#include <cmath>
#include "edoRepairerApply.h"
/**
*
* @ingroup Repairers
*/
template < typename EOT >
class edoRepairerModulo: public edoRepairerApplyBinary<EOT>
{
public:
edoRepairerModulo<EOT>( double denominator ) : edoRepairerApplyBinary<EOT>( std::fmod, denominator ) {}
};
#endif // !_edoRepairerModulo_h

28
edo/src/edoRepairerRound.h
View file

@ -30,38 +30,32 @@ Authors:
#include <cmath>
#include "edoRepairer.h"
#include "edoRepairerApply.h"
/**
/** A repairer that calls "floor" on each items of a solution
*
* Just a proxy to "edoRepairerApplyUnary<EOT, EOT::AtomType(EOT::AtomType)> rep( std::floor);"
*
* @ingroup Repairers
*/
template < typename EOT >
class edoRepairerFloor : public edoRepairer<EOT>
class edoRepairerFloor : public edoRepairerApplyUnary<EOT>
{
public:
virtual void operator()( EOT& sol )
{
for( unsigned int i=0; i < sol.size(); ++i ) {
sol[i] = floor( sol[i] );
}
}
edoRepairerFloor() : edoRepairerApplyUnary<EOT>( std::floor ) {}
};
/**
/** A repairer that calls "ceil" on each items of a solution
*
* @see edoRepairerFloor
*
* @ingroup Repairers
*/
template < typename EOT >
class edoRepairerCeil : public edoRepairer<EOT>
class edoRepairerCeil : public edoRepairerApplyUnary<EOT>
{
public:
virtual void operator()( EOT& sol )
{
for( unsigned int i=0; i < sol.size(); ++i ) {
sol[i] = ceil( sol[i] );
}
}
edoRepairerCeil() : edoRepairerApplyUnary<EOT>( std::ceil ) {}
};

1
edo/test/CMakeLists.txt
View file

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

55
edo/test/t-repairer-modulo.cpp Normal file
View file

@ -0,0 +1,55 @@
/*
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>
*/
#define _USE_MATH_DEFINES
#include <math.h>
#include <eo>
#include <edo>
#include <es.h>
typedef eoReal< eoMinimizingFitness > EOT;
int main(void)
{
EOT sol;
sol.push_back( M_PI * 1 );
sol.push_back( M_PI * 2 );
sol.push_back( M_PI * 3 );
sol.push_back( M_PI * 4 );
sol.push_back( M_PI * 4 + M_PI / 2 );
sol.push_back( M_PI * 5 + M_PI / 2 );
// we expect {pi,0,pi,0,pi/2,pi+pi/2}
std::cout << "expect: INVALID 4 3.14159 0 3.14159 0 1.5708 4.71239" << std::endl;
edoRepairer<EOT>* repare = new edoRepairerModulo<EOT>( 2 * M_PI ); // modulo 2pi
(*repare)(sol);
std::cout << sol << std::endl;
return 0;
}