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

Removed "using namespace std" statements from header files in EO -- "std::" identifier were added where necessary.

Browse source
This commit is contained in:
okoenig 2003-02-27 19:28:07 +00:00
commit 86fa476c67
263 changed files with 2009 additions and 1976 deletions
Download patch file Download diff file Expand all files Collapse all files

2
eo/app/mastermind/mastermind.cpp
View file

@ -10,6 +10,8 @@
#include <eo> // all usefull eo stuff #include <eo> // all usefull eo stuff
#include "mastermind.h" // Chrom eoChromInit eoChromMutation eoChromXover eoChromEvaluator #include "mastermind.h" // Chrom eoChromInit eoChromMutation eoChromXover eoChromEvaluator
using namespace std;
//----------------------------------------------------------------------------- //-----------------------------------------------------------------------------
// global variables // global variables
//----------------------------------------------------------------------------- //-----------------------------------------------------------------------------

14
eo/app/mastermind/mastermind.h
View file

@ -23,7 +23,7 @@ typedef float phenotype;
// genotype // genotype
//----------------------------------------------------------------------------- //-----------------------------------------------------------------------------
typedef vector<int> genotype; typedef std::vector<int> genotype;
//----------------------------------------------------------------------------- //-----------------------------------------------------------------------------
// Chrom // Chrom
@ -67,12 +67,12 @@ phenotype eoChromEvaluator(const Chrom& chrom)
const unsigned default_length = 8; const unsigned default_length = 8;
const unsigned default_colors = 8; const unsigned default_colors = 8;
const string default_solution = "01234567"; const std::string default_solution = "01234567";
unsigned num_colors; unsigned num_colors;
void init_eoChromEvaluator(const unsigned& c, const unsigned& l, string s) void init_eoChromEvaluator(const unsigned& c, const unsigned& l, std::string s)
{ {
num_colors = c; num_colors = c;
@ -82,14 +82,14 @@ void init_eoChromEvaluator(const unsigned& c, const unsigned& l, string s)
// check length // check length
if (l != default_length && s.size() != l) if (l != default_length && s.size() != l)
{ {
cerr << "solution length != length" << endl; std::cerr << "solution length != length" << std::endl;
exit(EXIT_FAILURE); exit(EXIT_FAILURE);
} }
// check number of colors // check number of colors
if (c != default_colors && c < *max_element(s.begin(), s.end()) - '0') if (c != default_colors && c < *max_element(s.begin(), s.end()) - '0')
{ {
cerr << "too high color number found!" << endl; std::cerr << "too high color number found!" << std::endl;
exit(EXIT_FAILURE); exit(EXIT_FAILURE);
} }
} }
@ -160,12 +160,12 @@ class eoChromMutation: public eoMonOp<Chrom>
case 1: case 1:
{ {
// transposition // transposition
swap(chrom[position()], chrom[position()]); std::swap(chrom[position()], chrom[position()]);
break; break;
} }
default: default:
{ {
cerr << "unknown operator!" << endl; std::cerr << "unknown operator!" << std::endl;
exit(EXIT_FAILURE); exit(EXIT_FAILURE);
break; break;
} }

2
eo/configure.in
View file

@ -34,5 +34,5 @@ AC_TYPE_SIZE_T
dnl Checks for library functions. dnl Checks for library functions.
AC_CHECK_FUNCS(select) AC_CHECK_FUNCS(select)
AC_OUTPUT(src/obsolete/Makefile doc/Makefile src/Makefile src/utils/Makefile src/other/Makefile win/Makefile src/gp/Makefile src/es/Makefile src/ga/Makefile src/do/Makefile test/Makefile contrib/Makefile Makefile app/Makefile app/gprop/Makefile app/mastermind/Makefile app/gpsymreg/Makefile) AC_OUTPUT(src/obsolete/Makefile doc/Makefile src/Makefile src/utils/Makefile src/other/Makefile win/Makefile src/gp/Makefile src/es/Makefile src/ga/Makefile test/Makefile contrib/Makefile Makefile app/Makefile app/gprop/Makefile app/mastermind/Makefile app/gpsymreg/Makefile)

14
eo/contrib/MGE/VirusOp.h
View file

@ -18,7 +18,7 @@
Contact: todos@geneura.ugr.es, http://geneura.ugr.es Contact: todos@geneura.ugr.es, http://geneura.ugr.es
Marc.Schoenauer@polytechnique.fr Marc.Schoenauer@polytechnique.fr
CVS Info: $Date: 2001-12-03 16:28:30 $ $Header: /home/nojhan/dev/eodev/eodev_cvs/eo/contrib/MGE/VirusOp.h,v 1.2 2001-12-03 16:28:30 evomarc Exp $ $Author: evomarc $ CVS Info: $Date: 2003-02-27 19:26:43 $ $Header: /home/nojhan/dev/eodev/eodev_cvs/eo/contrib/MGE/VirusOp.h,v 1.3 2003-02-27 19:26:43 okoenig Exp $ $Author: okoenig $
*/ */
#ifndef VirusOp_h #ifndef VirusOp_h
@ -28,7 +28,7 @@ CVS Info: $Date: 2001-12-03 16:28:30 $ $Header: /home/nojhan/dev/eodev/eodev_cvs
#include <iostream> // ostream, istream #include <iostream> // ostream, istream
#include <functional> // bind2nd #include <functional> // bind2nd
#include <string> // string #include <string> // std::string
#include <utils/eoRNG.h> #include <utils/eoRNG.h>
#include "../contrib/MGE/eoVirus.h" #include "../contrib/MGE/eoVirus.h"
@ -40,7 +40,7 @@ template<class FitT>
class VirusBitFlip: public eoMonOp<eoVirus<FitT> > { class VirusBitFlip: public eoMonOp<eoVirus<FitT> > {
public: public:
/// The class name. /// The class name.
virtual string className() const { return "VirusBitFlip"; }; virtual std::string className() const { return "VirusBitFlip"; };
/** /**
* Change one bit. * Change one bit.
@ -57,7 +57,7 @@ template<class FitT>
class VirusMutation: public eoMonOp<eoVirus<FitT> > { class VirusMutation: public eoMonOp<eoVirus<FitT> > {
public: public:
/// The class name. /// The class name.
virtual string className() const { return "VirusMutation"; }; virtual std::string className() const { return "VirusMutation"; };
/** /**
* Change one bit. * Change one bit.
@ -65,7 +65,7 @@ class VirusMutation: public eoMonOp<eoVirus<FitT> > {
*/ */
bool operator()(eoVirus<FitT>& _chrom) { bool operator()(eoVirus<FitT>& _chrom) {
// Search for virus bits // Search for virus bits
vector<unsigned> bitsSet; std::vector<unsigned> bitsSet;
for ( unsigned i = 0; i < _chrom.size(); i ++ ) { for ( unsigned i = 0; i < _chrom.size(); i ++ ) {
if ( _chrom.virusBit(i) ) { if ( _chrom.virusBit(i) ) {
bitsSet.push_back( i ); bitsSet.push_back( i );
@ -90,7 +90,7 @@ class VirusShiftMutation: public eoMonOp<eoVirus<FitT> > {
VirusShiftMutation( ) {}; VirusShiftMutation( ) {};
/// The class name. /// The class name.
virtual string className() const { return "VirusShiftMutation"; }; virtual std::string className() const { return "VirusShiftMutation"; };
/** /**
* Change one bit. * Change one bit.
@ -125,7 +125,7 @@ template<class FitT>
class VirusTransmission: public eoBinOp<eoVirus<FitT> > { class VirusTransmission: public eoBinOp<eoVirus<FitT> > {
public: public:
/// The class name. /// The class name.
virtual string className() const { return "VirusTransmission"; }; virtual std::string className() const { return "VirusTransmission"; };
/** /**
* Change one bit. * Change one bit.

26
eo/contrib/MGE/eoVirus.h
View file

@ -18,7 +18,7 @@
Contact: todos@geneura.ugr.es, http://geneura.ugr.es Contact: todos@geneura.ugr.es, http://geneura.ugr.es
Marc.Schoenauer@polytechnique.fr Marc.Schoenauer@polytechnique.fr
CVS Info: $Date: 2001-05-17 10:08:25 $ $Header: /home/nojhan/dev/eodev/eodev_cvs/eo/contrib/MGE/eoVirus.h,v 1.1 2001-05-17 10:08:25 jmerelo Exp $ $Author: jmerelo $ CVS Info: $Date: 2003-02-27 19:26:44 $ $Header: /home/nojhan/dev/eodev/eodev_cvs/eo/contrib/MGE/eoVirus.h,v 1.2 2003-02-27 19:26:44 okoenig Exp $ $Author: okoenig $
*/ */
#ifndef eoVirus_h #ifndef eoVirus_h
@ -28,7 +28,7 @@ CVS Info: $Date: 2001-05-17 10:08:25 $ $Header: /home/nojhan/dev/eodev/eodev_cvs
#include <iostream> // ostream, istream #include <iostream> // ostream, istream
#include <functional> // bind2nd #include <functional> // bind2nd
#include <string> // string #include <string> // std::string
#include <ga/eoBit.h> #include <ga/eoBit.h>
@ -49,13 +49,13 @@ template <class FitT> class eoVirus: public eoBit<FitT>
/** /**
* (Default) Constructor. * (Default) Constructor.
* @param size Size of the binary string. * @param size Size of the binary std::string.
*/ */
eoVirus(unsigned _size = 0, bool _value = false, bool _virValue = false): eoVirus(unsigned _size = 0, bool _value = false, bool _virValue = false):
eoBit<FitT>(_size, _value), virus( _size, _virValue) {} eoBit<FitT>(_size, _value), virus( _size, _virValue) {}
/// My class name. /// My class name.
virtual string className() const { virtual std::string className() const {
return "eoVirus"; return "eoVirus";
} }
@ -78,33 +78,33 @@ template <class FitT> class eoVirus: public eoBit<FitT>
* To print me on a stream. * To print me on a stream.
* @param os The ostream. * @param os The ostream.
*/ */
virtual void printOn(ostream& os) const { virtual void printOn(std::ostream& os) const {
EO<FitT>::printOn(os); EO<FitT>::printOn(os);
os << ' '; os << ' ';
os << size() << ' '; os << size() << ' ';
copy(begin(), end(), ostream_iterator<bool>(os)); std::copy(begin(), end(), std::ostream_iterator<bool>(os));
cout << endl; std::cout << std::endl;
copy(virus.begin(), virus.end(), ostream_iterator<bool>(os)); std::copy(virus.begin(), virus.end(), std::ostream_iterator<bool>(os));
} }
/** /**
* To read me from a stream. * To read me from a stream.
* @param is The istream. * @param is The istream.
*/ */
virtual void readFrom(istream& is){ virtual void readFrom(std::istream& is){
eoBit<FitT>::readFrom(is); eoBit<FitT>::readFrom(is);
unsigned s; unsigned s;
is >> s; is >> s;
string bits; std::string bits;
is >> bits; is >> bits;
if (is) { if (is) {
virus.resize(bits.size()); virus.resize(bits.size());
transform(bits.begin(), bits.end(), virus.begin(), std::transform(bits.begin(), bits.end(), virus.begin(),
bind2nd(equal_to<char>(), '1')); std::bind2nd(std::equal_to<char>(), '1'));
} }
} }
private: private:
vector<bool> virus; std::vector<bool> virus;
}; };
//----------------------------------------------------------------------------- //-----------------------------------------------------------------------------

4
eo/contrib/eoAged.h
View file

@ -29,7 +29,7 @@
//----------------------------------------------------------------------------- //-----------------------------------------------------------------------------
#include <iostream> // istream, ostream #include <iostream> // istream, ostream
#include <string> // para string #include <std::string> // para std::string
using namespace std; using namespace std;
@ -71,7 +71,7 @@ class eoAged: public Object
it's got code as an example of implementation. Only "leaf" classes it's got code as an example of implementation. Only "leaf" classes
can be non-virtual. can be non-virtual.
*/ */
virtual string className() const { return string("eoAged")+Object::className(); }; virtual std::string className() const { return std::string("eoAged")+Object::className(); };
/** /**
* Read object. * Read object.

20
eo/src/EO.h
View file

@ -27,7 +27,7 @@
//----------------------------------------------------------------------------- //-----------------------------------------------------------------------------
#include <stdexcept> // runtime_error #include <stdexcept> // std::runtime_error
#include <eoObject.h> // eoObject #include <eoObject.h> // eoObject
#include <eoPersistent.h> // eoPersistent #include <eoPersistent.h> // eoPersistent
@ -59,7 +59,7 @@ public:
/// Return fitness value. /// Return fitness value.
Fitness fitness() const { Fitness fitness() const {
if (invalid()) if (invalid())
throw runtime_error("invalid fitness"); throw std::runtime_error("invalid fitness");
return repFitness; return repFitness;
} }
@ -90,23 +90,23 @@ public:
//@{ //@{
/** Return the class id. /** Return the class id.
* @return the class name as a string * @return the class name as a std::string
*/ */
virtual string className() const { return "EO"; } virtual std::string className() const { return "EO"; }
/** /**
* Read object.\\ * Read object.\\
* Calls base class, just in case that one had something to do. * Calls base class, just in case that one had something to do.
* The read and print methods should be compatible and have the same format. * The read and print methods should be compatible and have the same format.
* In principle, format is "plain": they just print a number * In principle, format is "plain": they just print a number
* @param _is a istream. * @param _is a std::istream.
* @throw runtime_exception If a valid object can't be read. * @throw runtime_std::exception If a valid object can't be read.
*/ */
virtual void readFrom(istream& _is) { virtual void readFrom(std::istream& _is) {
// the new version of the reafFrom function. // the new version of the reafFrom function.
// It can distinguish between valid and invalid fitness values. // It can distinguish between valid and invalid fitness values.
string fitness_str; std::string fitness_str;
int pos = _is.tellg(); int pos = _is.tellg();
_is >> fitness_str; _is >> fitness_str;
@ -124,9 +124,9 @@ public:
/** /**
* Write object. Called printOn since it prints the object _on_ a stream. * Write object. Called printOn since it prints the object _on_ a stream.
* @param _os A ostream. * @param _os A std::ostream.
*/ */
virtual void printOn(ostream& _os) const { virtual void printOn(std::ostream& _os) const {
// the latest version of the code. Very similar to the old code // the latest version of the code. Very similar to the old code

2
eo/src/apply.h
View file

@ -30,7 +30,7 @@
#include <vector> #include <vector>
/** /**
Applies a unary function to a vector of things. Applies a unary function to a std::vector of things.
*/ */
template <class EOT> template <class EOT>
void apply(eoUF<EOT&, void>& _proc, std::vector<EOT>& _pop) void apply(eoUF<EOT&, void>& _proc, std::vector<EOT>& _pop)

88
eo/src/do/make_algo_easea.h
View file

@ -77,40 +77,40 @@ eoAlgo<EOT> & do_make_algo_scalar(eoParser& _parser, eoState& _state, eoEvalFunc
// the selection // the selection
eoValueParam<eoParamParamType>& selectionParam = _parser.createParam(eoParamParamType("DetTour(2)"), "selection", "Selection: Roulette, Ranking(p,e), DetTour(T), StochTour(t), Sequential(ordered/unordered) or EliteSequentialSelect", 'S', "Evolution Engine"); eoValueParam<eoParamParamType>& selectionParam = _parser.createParam(eoParamParamType("DetTour(2)"), "selection", "Selection: Roulette, Ranking(p,e), DetTour(T), StochTour(t), Sequential(ordered/unordered) or EliteSequentialSelect", 'S', "Evolution Engine");
eoParamParamType & ppSelect = selectionParam.value(); // pair<string,vector<string> > eoParamParamType & ppSelect = selectionParam.value(); // std::pair<std::string,std::vector<std::string> >
eoSelectOne<EOT>* select ; eoSelectOne<EOT>* select ;
if (ppSelect.first == string("DetTour")) if (ppSelect.first == std::string("DetTour"))
{ {
unsigned detSize; unsigned detSize;
if (!ppSelect.second.size()) // no parameter added if (!ppSelect.second.size()) // no parameter added
{ {
cerr << "WARNING, no parameter passed to DetTour, using 2" << endl; std::cerr << "WARNING, no parameter passed to DetTour, using 2" << std::endl;
detSize = 2; detSize = 2;
// put back 2 in parameter for consistency (and status file) // put back 2 in parameter for consistency (and status file)
ppSelect.second.push_back(string("2")); ppSelect.second.push_back(std::string("2"));
} }
else // parameter passed by user as DetTour(T) else // parameter passed by user as DetTour(T)
detSize = atoi(ppSelect.second[0].c_str()); detSize = atoi(ppSelect.second[0].c_str());
select = new eoDetTournamentSelect<EOT>(detSize); select = new eoDetTournamentSelect<EOT>(detSize);
} }
else if (ppSelect.first == string("StochTour")) else if (ppSelect.first == std::string("StochTour"))
{ {
double p; double p;
if (!ppSelect.second.size()) // no parameter added if (!ppSelect.second.size()) // no parameter added
{ {
cerr << "WARNING, no parameter passed to StochTour, using 1" << endl; std::cerr << "WARNING, no parameter passed to StochTour, using 1" << std::endl;
p = 1; p = 1;
// put back p in parameter for consistency (and status file) // put back p in parameter for consistency (and status file)
ppSelect.second.push_back(string("1")); ppSelect.second.push_back(std::string("1"));
} }
else // parameter passed by user as DetTour(T) else // parameter passed by user as DetTour(T)
p = atof(ppSelect.second[0].c_str()); p = atof(ppSelect.second[0].c_str());
select = new eoStochTournamentSelect<EOT>(p); select = new eoStochTournamentSelect<EOT>(p);
} }
else if (ppSelect.first == string("Ranking")) else if (ppSelect.first == std::string("Ranking"))
{ {
double p,e; double p,e;
if (ppSelect.second.size()==2) // 2 parameters: pressure and exponent if (ppSelect.second.size()==2) // 2 parameters: pressure and exponent
@ -120,69 +120,69 @@ eoAlgo<EOT> & do_make_algo_scalar(eoParser& _parser, eoState& _state, eoEvalFunc
} }
else if (ppSelect.second.size()==1) // 1 parameter: pressure else if (ppSelect.second.size()==1) // 1 parameter: pressure
{ {
cerr << "WARNING, no exponent to Ranking, using 1" << endl; std::cerr << "WARNING, no exponent to Ranking, using 1" << std::endl;
e = 1; e = 1;
ppSelect.second.push_back(string("1")); ppSelect.second.push_back(std::string("1"));
p = atof(ppSelect.second[0].c_str()); p = atof(ppSelect.second[0].c_str());
} }
else // no parameters ... or garbage else // no parameters ... or garbage
{ {
cerr << "WARNING, no parameter to Ranking, using (2,1)" << endl; std::cerr << "WARNING, no parameter to Ranking, using (2,1)" << std::endl;
p=2; p=2;
e=1; e=1;
// put back in parameter for consistency (and status file) // put back in parameter for consistency (and status file)
ppSelect.second.resize(2); // just in case ppSelect.second.resize(2); // just in case
ppSelect.second[0] = (string("2")); ppSelect.second[0] = (std::string("2"));
ppSelect.second[1] = (string("1")); ppSelect.second[1] = (std::string("1"));
} }
// check for authorized values // check for authorized values
// pressure in (0,1] // pressure in (0,1]
if ( (p<=1) || (p>2) ) if ( (p<=1) || (p>2) )
{ {
cerr << "WARNING, selective pressure must be in (1,2] in Ranking, using 2\n"; std::cerr << "WARNING, selective pressure must be in (1,2] in Ranking, using 2\n";
p=2; p=2;
ppSelect.second[0] = (string("2")); ppSelect.second[0] = (std::string("2"));
} }
// exponent >0 // exponent >0
if (e<=0) if (e<=0)
{ {
cerr << "WARNING, exponent must be positive in Ranking, using 1\n"; std::cerr << "WARNING, exponent must be positive in Ranking, using 1\n";
e=1; e=1;
ppSelect.second[1] = (string("1")); ppSelect.second[1] = (std::string("1"));
} }
// now we're OK // now we're OK
eoPerf2Worth<EOT> & p2w = _state.storeFunctor( new eoRanking<EOT>(p,e) ); eoPerf2Worth<EOT> & p2w = _state.storeFunctor( new eoRanking<EOT>(p,e) );
select = new eoRouletteWorthSelect<EOT>(p2w); select = new eoRouletteWorthSelect<EOT>(p2w);
} }
else if (ppSelect.first == string("Sequential")) // one after the other else if (ppSelect.first == std::string("Sequential")) // one after the other
{ {
bool b; bool b;
if (ppSelect.second.size() == 0) // no argument -> default = ordered if (ppSelect.second.size() == 0) // no argument -> default = ordered
{ {
b=true; b=true;
// put back in parameter for consistency (and status file) // put back in parameter for consistency (and status file)
ppSelect.second.push_back(string("ordered")); ppSelect.second.push_back(std::string("ordered"));
} }
else else
b = !(ppSelect.second[0] == string("unordered")); b = !(ppSelect.second[0] == std::string("unordered"));
select = new eoSequentialSelect<EOT>(b); select = new eoSequentialSelect<EOT>(b);
} }
else if (ppSelect.first == string("EliteSequential")) // Best first, one after the other in random order afterwards else if (ppSelect.first == std::string("EliteSequential")) // Best first, one after the other in random order afterwards
{ {
select = new eoEliteSequentialSelect<EOT>; select = new eoEliteSequentialSelect<EOT>;
} }
else if (ppSelect.first == string("Roulette")) // no argument (yet) else if (ppSelect.first == std::string("Roulette")) // no argument (yet)
{ {
select = new eoProportionalSelect<EOT>; select = new eoProportionalSelect<EOT>;
} }
else if (ppSelect.first == string("Random")) // no argument else if (ppSelect.first == std::string("Random")) // no argument
{ {
select = new eoRandomSelect<EOT>; select = new eoRandomSelect<EOT>;
} }
else else
{ {
string stmp = string("Invalid selection: ") + ppSelect.first; std::string stmp = std::string("Invalid selection: ") + ppSelect.first;
throw runtime_error(stmp.c_str()); throw std::runtime_error(stmp.c_str());
} }
_state.storeFunctor(select); _state.storeFunctor(select);
@ -228,7 +228,7 @@ eoAlgo<EOT> & do_make_algo_scalar(eoParser& _parser, eoState& _state, eoEvalFunc
// first, separate G3 and MGG // first, separate G3 and MGG
// maybe one day we have a common class - but is it really necessary??? // maybe one day we have a common class - but is it really necessary???
if (replacementParam.first == string("G3")) if (replacementParam.first == std::string("G3"))
{ {
// reduce the parents: by default, survive parents = -2 === 2 parents die // reduce the parents: by default, survive parents = -2 === 2 parents die
eoHowMany surviveParents = _parser.createParam(eoHowMany(-2,false), "surviveParents", "Nb of surviving parents (percentage or absolute)", '\0', "Evolution Engine / Replacement").value(); eoHowMany surviveParents = _parser.createParam(eoHowMany(-2,false), "surviveParents", "Nb of surviving parents (percentage or absolute)", '\0', "Evolution Engine / Replacement").value();
@ -236,7 +236,7 @@ eoAlgo<EOT> & do_make_algo_scalar(eoParser& _parser, eoState& _state, eoEvalFunc
ptReplace = new eoG3Replacement<EOT>(-surviveParents); // must receive nb of eliminated parets! ptReplace = new eoG3Replacement<EOT>(-surviveParents); // must receive nb of eliminated parets!
_state.storeFunctor(ptReplace); _state.storeFunctor(ptReplace);
} }
else if (replacementParam.first == string("MGG")) else if (replacementParam.first == std::string("MGG"))
{ {
float t; float t;
unsigned tSize; unsigned tSize;
@ -245,10 +245,10 @@ eoAlgo<EOT> & do_make_algo_scalar(eoParser& _parser, eoState& _state, eoEvalFunc
// the tournament size // the tournament size
if (!replacementParam.second.size()) // no parameter added if (!replacementParam.second.size()) // no parameter added
{ {
cerr << "WARNING, no parameter passed to MGG replacement, using 2" << endl; std::cerr << "WARNING, no parameter passed to MGG replacement, using 2" << std::endl;
tSize = 2; tSize = 2;
// put back 2 in parameter for consistency (and status file) // put back 2 in parameter for consistency (and status file)
replacementParam.second.push_back(string("2")); replacementParam.second.push_back(std::string("2"));
} }
else else
{ {
@ -259,7 +259,7 @@ eoAlgo<EOT> & do_make_algo_scalar(eoParser& _parser, eoState& _state, eoEvalFunc
} }
else else
{ {
throw runtime_error("Sorry, only deterministic tournament available at the moment"); throw std::runtime_error("Sorry, only deterministic tournament available at the moment");
} }
} }
ptReplace = new eoMGGReplacement<EOT>(-surviveParents, tSize); ptReplace = new eoMGGReplacement<EOT>(-surviveParents, tSize);
@ -280,58 +280,58 @@ eoAlgo<EOT> & do_make_algo_scalar(eoParser& _parser, eoState& _state, eoEvalFunc
double t; double t;
// ---------- General // ---------- General
if (replacementParam.first == string("General")) if (replacementParam.first == std::string("General"))
{ {
; // defaults OK ; // defaults OK
} }
// ---------- ESComma // ---------- ESComma
else if (replacementParam.first == string("ESComma")) else if (replacementParam.first == std::string("ESComma"))
{ {
; // OK too ; // OK too
} }
// ---------- ESPlus // ---------- ESPlus
else if (replacementParam.first == string("ESPlus")) else if (replacementParam.first == std::string("ESPlus"))
{ {
surviveParents = eoHowMany(1.0); surviveParents = eoHowMany(1.0);
} }
// ---------- Generational // ---------- Generational
else if (replacementParam.first == string("Generational")) else if (replacementParam.first == std::string("Generational"))
{ {
; // OK too (we should check nb of offspring) ; // OK too (we should check nb of offspring)
} }
// ---------- EP // ---------- EP
else if (replacementParam.first == string("EP")) else if (replacementParam.first == std::string("EP"))
{ {
if (!replacementParam.second.size()) // no parameter added if (!replacementParam.second.size()) // no parameter added
{ {
cerr << "WARNING, no parameter passed to EP replacement, using 6" << endl; std::cerr << "WARNING, no parameter passed to EP replacement, using 6" << std::endl;
// put back 6 in parameter for consistency (and status file) // put back 6 in parameter for consistency (and status file)
replacementParam.second.push_back(string("6")); replacementParam.second.push_back(std::string("6"));
} }
// by coincidence, the syntax for the EP reducer is the same than here: // by coincidence, the syntax for the EP reducer is the same than here:
reduceFinalType = replacementParam; reduceFinalType = replacementParam;
surviveParents = eoHowMany(1.0); surviveParents = eoHowMany(1.0);
} }
// ---------- SSGA // ---------- SSGA
else if (replacementParam.first == string("SSGA")) else if (replacementParam.first == std::string("SSGA"))
{ {
if (!replacementParam.second.size()) // no parameter added if (!replacementParam.second.size()) // no parameter added
{ {
cerr << "WARNING, no parameter passed to SSGA replacement, using 2" << endl; std::cerr << "WARNING, no parameter passed to SSGA replacement, using 2" << std::endl;
// put back 2 in parameter for consistency (and status file) // put back 2 in parameter for consistency (and status file)
replacementParam.second.push_back(string("2")); replacementParam.second.push_back(std::string("2"));
reduceParentType = eoParamParamType(string("DetTour(2)")); reduceParentType = eoParamParamType(std::string("DetTour(2)"));
} }
else else
{ {
t = atof(replacementParam.second[0].c_str()); t = atof(replacementParam.second[0].c_str());
if (t>=2) if (t>=2)
{ // build the appropriate deafult value { // build the appropriate deafult value
reduceParentType = eoParamParamType(string("DetTour(") + replacementParam.second[0].c_str() + ")"); reduceParentType = eoParamParamType(std::string("DetTour(") + replacementParam.second[0].c_str() + ")");
} }
else // check for [0.5,1] will be made in make_general_replacement else // check for [0.5,1] will be made in make_general_replacement
{ // build the appropriate deafult value { // build the appropriate deafult value
reduceParentType = eoParamParamType(string("StochTour(") + replacementParam.second[0].c_str() + ")"); reduceParentType = eoParamParamType(std::string("StochTour(") + replacementParam.second[0].c_str() + ")");
} }
} }
// //
@ -340,7 +340,7 @@ eoAlgo<EOT> & do_make_algo_scalar(eoParser& _parser, eoState& _state, eoEvalFunc
} }
else // no replacement recognized else // no replacement recognized
{ {
throw runtime_error("Invalid replacement type " + replacementParam.first); throw std::runtime_error("Invalid replacement type " + replacementParam.first);
} }
ptReplace = & make_general_replacement<EOT>( ptReplace = & make_general_replacement<EOT>(

38
eo/src/do/make_algo_pareto.h
View file

@ -47,7 +47,7 @@ class eoNDPlusReplacement : public eoReplacement<EOT>
public: public:
eoNDPlusReplacement(eoPerf2Worth<EOT, WorthT>& _perf2worth) : perf2worth(_perf2worth) {} eoNDPlusReplacement(eoPerf2Worth<EOT, WorthT>& _perf2worth) : perf2worth(_perf2worth) {}
struct WorthPair : public pair<WorthT, const EOT*> struct WorthPair : public std::pair<WorthT, const EOT*>
{ {
bool operator<(const WorthPair& other) const { return other.first < first; } bool operator<(const WorthPair& other) const { return other.first < first; }
}; };
@ -96,14 +96,14 @@ template <class EOT>
eoAlgo<EOT> & do_make_algo_pareto(eoParser& _parser, eoState& _state, eoEvalFunc<EOT>& _eval, eoContinue<EOT>& _continue, eoGenOp<EOT>& _op) eoAlgo<EOT> & do_make_algo_pareto(eoParser& _parser, eoState& _state, eoEvalFunc<EOT>& _eval, eoContinue<EOT>& _continue, eoGenOp<EOT>& _op)
{ {
// the selection // the selection
string & selStr = _parser.createParam(string("NSGA-II"), "selCrit", "Pareto Selection Criterion: NSGA, NSGA-II, ParetoRanking", 'S', "Evolution Engine").value(); std::string & selStr = _parser.createParam(std::string("NSGA-II"), "selCrit", "Pareto Selection Criterion: NSGA, NSGA-II, ParetoRanking", 'S', "Evolution Engine").value();
double nicheSize = _parser.createParam(1.0, "nicheSize", "Size of niche for NSGA-I", '\0', "Evolution Engine").value(); double nicheSize = _parser.createParam(1.0, "nicheSize", "Size of niche for NSGA-I", '\0', "Evolution Engine").value();
eoPerf2Worth<EOT, double> *p2w; eoPerf2Worth<EOT, double> *p2w;
if ( (selStr == string("NSGA")) || (selStr == string("NSGA-I") ) ) if ( (selStr == std::string("NSGA")) || (selStr == std::string("NSGA-I") ) )
p2w = new eoNDSorting_I<EOT>(nicheSize); p2w = new eoNDSorting_I<EOT>(nicheSize);
else if (selStr == string("NSGA-II")) else if (selStr == std::string("NSGA-II"))
p2w = new eoNDSorting_II<EOT>(); p2w = new eoNDSorting_II<EOT>();
else if (selStr == string("ParetoRanking")) else if (selStr == std::string("ParetoRanking"))
{ {
eoDominanceMap<EOT>& dominance = _state.storeFunctor(new eoDominanceMap<EOT>); eoDominanceMap<EOT>& dominance = _state.storeFunctor(new eoDominanceMap<EOT>);
p2w = new eoParetoRanking<EOT>(dominance); p2w = new eoParetoRanking<EOT>(dominance);
@ -116,64 +116,64 @@ eoAlgo<EOT> & do_make_algo_pareto(eoParser& _parser, eoState& _state, eoEvalFunc
// only the ranking is not re-implemented (yet?) // only the ranking is not re-implemented (yet?)
eoValueParam<eoParamParamType>& selectionParam = _parser.createParam(eoParamParamType("DetTour(2)"), "selection", "Selection: Roulette, DetTour(T), StochTour(t) or Random", 'S', "Evolution Engine"); eoValueParam<eoParamParamType>& selectionParam = _parser.createParam(eoParamParamType("DetTour(2)"), "selection", "Selection: Roulette, DetTour(T), StochTour(t) or Random", 'S', "Evolution Engine");
eoParamParamType & ppSelect = selectionParam.value(); // pair<string,vector<string> > eoParamParamType & ppSelect = selectionParam.value(); // std::pair<std::string,std::vector<std::string> >
eoSelectOne<EOT>* select ; eoSelectOne<EOT>* select ;
if (ppSelect.first == string("DetTour")) if (ppSelect.first == std::string("DetTour"))
{ {
unsigned detSize; unsigned detSize;
if (!ppSelect.second.size()) // no parameter added if (!ppSelect.second.size()) // no parameter added
{ {
cerr << "WARNING, no parameter passed to DetTour, using 2" << endl; std::cerr << "WARNING, no parameter passed to DetTour, using 2" << std::endl;
detSize = 2; detSize = 2;
// put back 2 in parameter for consistency (and status file) // put back 2 in parameter for consistency (and status file)
ppSelect.second.push_back(string("2")); ppSelect.second.push_back(std::string("2"));
} }
else // parameter passed by user as DetTour(T) else // parameter passed by user as DetTour(T)
detSize = atoi(ppSelect.second[0].c_str()); detSize = atoi(ppSelect.second[0].c_str());
select = new eoDetTournamentWorthSelect<EOT>(*p2w, detSize); select = new eoDetTournamentWorthSelect<EOT>(*p2w, detSize);
} }
else if (ppSelect.first == string("StochTour")) else if (ppSelect.first == std::string("StochTour"))
{ {
double p; double p;
if (!ppSelect.second.size()) // no parameter added if (!ppSelect.second.size()) // no parameter added
{ {
cerr << "WARNING, no parameter passed to StochTour, using 1" << endl; std::cerr << "WARNING, no parameter passed to StochTour, using 1" << std::endl;
p = 1; p = 1;
// put back p in parameter for consistency (and status file) // put back p in parameter for consistency (and status file)
ppSelect.second.push_back(string("1")); ppSelect.second.push_back(std::string("1"));
} }
else // parameter passed by user as DetTour(T) else // parameter passed by user as DetTour(T)
p = atof(ppSelect.second[0].c_str()); p = atof(ppSelect.second[0].c_str());
select = new eoStochTournamentWorthSelect<EOT>(*p2w, p); select = new eoStochTournamentWorthSelect<EOT>(*p2w, p);
} }
// else if (ppSelect.first == string("Sequential")) // one after the other // else if (ppSelect.first == std::string("Sequential")) // one after the other
// { // {
// bool b; // bool b;
// if (ppSelect.second.size() == 0) // no argument -> default = ordered // if (ppSelect.second.size() == 0) // no argument -> default = ordered
// { // {
// b=true; // b=true;
// // put back in parameter for consistency (and status file) // // put back in parameter for consistency (and status file)
// ppSelect.second.push_back(string("ordered")); // ppSelect.second.push_back(std::string("ordered"));
// } // }
// else // else
// b = !(ppSelect.second[0] == string("unordered")); // b = !(ppSelect.second[0] == std::string("unordered"));
// select = new eoSequentialWorthSelect<EOT>(b); // select = new eoSequentialWorthSelect<EOT>(b);
// } // }
else if (ppSelect.first == string("Roulette")) // no argument (yet) else if (ppSelect.first == std::string("Roulette")) // no argument (yet)
{ {
select = new eoRouletteWorthSelect<EOT>(*p2w); select = new eoRouletteWorthSelect<EOT>(*p2w);
} }
else if (ppSelect.first == string("Random")) // no argument, no perf2Worth else if (ppSelect.first == std::string("Random")) // no argument, no perf2Worth
{ {
select = new eoRandomSelect<EOT>; select = new eoRandomSelect<EOT>;
} }
else else
{ {
string stmp = string("Invalid selection: ") + ppSelect.first; std::string stmp = std::string("Invalid selection: ") + ppSelect.first;
throw runtime_error(stmp.c_str()); throw std::runtime_error(stmp.c_str());
} }
_state.storeFunctor(select); _state.storeFunctor(select);

78
eo/src/do/make_algo_scalar.h
View file

@ -76,40 +76,40 @@ eoAlgo<EOT> & do_make_algo_scalar(eoParser& _parser, eoState& _state, eoEvalFunc
// the selection // the selection
eoValueParam<eoParamParamType>& selectionParam = _parser.createParam(eoParamParamType("DetTour(2)"), "selection", "Selection: Roulette, Ranking(p,e), DetTour(T), StochTour(t) or Sequential(ordered/unordered)", 'S', "Evolution Engine"); eoValueParam<eoParamParamType>& selectionParam = _parser.createParam(eoParamParamType("DetTour(2)"), "selection", "Selection: Roulette, Ranking(p,e), DetTour(T), StochTour(t) or Sequential(ordered/unordered)", 'S', "Evolution Engine");
eoParamParamType & ppSelect = selectionParam.value(); // pair<string,vector<string> > eoParamParamType & ppSelect = selectionParam.value(); // std::pair<std::string,std::vector<std::string> >
eoSelectOne<EOT>* select ; eoSelectOne<EOT>* select ;
if (ppSelect.first == string("DetTour")) if (ppSelect.first == std::string("DetTour"))
{ {
unsigned detSize; unsigned detSize;
if (!ppSelect.second.size()) // no parameter added if (!ppSelect.second.size()) // no parameter added
{ {
cerr << "WARNING, no parameter passed to DetTour, using 2" << endl; std::cerr << "WARNING, no parameter passed to DetTour, using 2" << std::endl;
detSize = 2; detSize = 2;
// put back 2 in parameter for consistency (and status file) // put back 2 in parameter for consistency (and status file)
ppSelect.second.push_back(string("2")); ppSelect.second.push_back(std::string("2"));
} }
else // parameter passed by user as DetTour(T) else // parameter passed by user as DetTour(T)
detSize = atoi(ppSelect.second[0].c_str()); detSize = atoi(ppSelect.second[0].c_str());
select = new eoDetTournamentSelect<EOT>(detSize); select = new eoDetTournamentSelect<EOT>(detSize);
} }
else if (ppSelect.first == string("StochTour")) else if (ppSelect.first == std::string("StochTour"))
{ {
double p; double p;
if (!ppSelect.second.size()) // no parameter added if (!ppSelect.second.size()) // no parameter added
{ {
cerr << "WARNING, no parameter passed to StochTour, using 1" << endl; std::cerr << "WARNING, no parameter passed to StochTour, using 1" << std::endl;
p = 1; p = 1;
// put back p in parameter for consistency (and status file) // put back p in parameter for consistency (and status file)
ppSelect.second.push_back(string("1")); ppSelect.second.push_back(std::string("1"));
} }
else // parameter passed by user as DetTour(T) else // parameter passed by user as DetTour(T)
p = atof(ppSelect.second[0].c_str()); p = atof(ppSelect.second[0].c_str());
select = new eoStochTournamentSelect<EOT>(p); select = new eoStochTournamentSelect<EOT>(p);
} }
else if (ppSelect.first == string("Ranking")) else if (ppSelect.first == std::string("Ranking"))
{ {
double p,e; double p,e;
if (ppSelect.second.size()==2) // 2 parameters: pressure and exponent if (ppSelect.second.size()==2) // 2 parameters: pressure and exponent
@ -119,65 +119,65 @@ eoAlgo<EOT> & do_make_algo_scalar(eoParser& _parser, eoState& _state, eoEvalFunc
} }
else if (ppSelect.second.size()==1) // 1 parameter: pressure else if (ppSelect.second.size()==1) // 1 parameter: pressure
{ {
cerr << "WARNING, no exponent to Ranking, using 1" << endl; std::cerr << "WARNING, no exponent to Ranking, using 1" << std::endl;
e = 1; e = 1;
ppSelect.second.push_back(string("1")); ppSelect.second.push_back(std::string("1"));
p = atof(ppSelect.second[0].c_str()); p = atof(ppSelect.second[0].c_str());
} }
else // no parameters ... or garbage else // no parameters ... or garbage
{ {
cerr << "WARNING, no parameter to Ranking, using (2,1)" << endl; std::cerr << "WARNING, no parameter to Ranking, using (2,1)" << std::endl;
p=2; p=2;
e=1; e=1;
// put back in parameter for consistency (and status file) // put back in parameter for consistency (and status file)
ppSelect.second.resize(2); // just in case ppSelect.second.resize(2); // just in case
ppSelect.second[0] = (string("2")); ppSelect.second[0] = (std::string("2"));
ppSelect.second[1] = (string("1")); ppSelect.second[1] = (std::string("1"));
} }
// check for authorized values // check for authorized values
// pressure in (0,1] // pressure in (0,1]
if ( (p<=1) || (p>2) ) if ( (p<=1) || (p>2) )
{ {
cerr << "WARNING, selective pressure must be in (0,1] in Ranking, using 2\n"; std::cerr << "WARNING, selective pressure must be in (0,1] in Ranking, using 2\n";
p=2; p=2;
ppSelect.second[0] = (string("2")); ppSelect.second[0] = (std::string("2"));
} }
// exponent >0 // exponent >0
if (e<=0) if (e<=0)
{ {
cerr << "WARNING, exponent must be positive in Ranking, using 1\n"; std::cerr << "WARNING, exponent must be positive in Ranking, using 1\n";
e=1; e=1;
ppSelect.second[1] = (string("1")); ppSelect.second[1] = (std::string("1"));
} }
// now we're OK // now we're OK
eoPerf2Worth<EOT> & p2w = _state.storeFunctor( new eoRanking<EOT>(p,e) ); eoPerf2Worth<EOT> & p2w = _state.storeFunctor( new eoRanking<EOT>(p,e) );
select = new eoRouletteWorthSelect<EOT>(p2w); select = new eoRouletteWorthSelect<EOT>(p2w);
} }
else if (ppSelect.first == string("Sequential")) // one after the other else if (ppSelect.first == std::string("Sequential")) // one after the other
{ {
bool b; bool b;
if (ppSelect.second.size() == 0) // no argument -> default = ordered if (ppSelect.second.size() == 0) // no argument -> default = ordered
{ {
b=true; b=true;
// put back in parameter for consistency (and status file) // put back in parameter for consistency (and status file)
ppSelect.second.push_back(string("ordered")); ppSelect.second.push_back(std::string("ordered"));
} }
else else
b = !(ppSelect.second[0] == string("unordered")); b = !(ppSelect.second[0] == std::string("unordered"));
select = new eoSequentialSelect<EOT>(b); select = new eoSequentialSelect<EOT>(b);
} }
else if (ppSelect.first == string("Roulette")) // no argument (yet) else if (ppSelect.first == std::string("Roulette")) // no argument (yet)
{ {
select = new eoProportionalSelect<EOT>; select = new eoProportionalSelect<EOT>;
} }
else if (ppSelect.first == string("Random")) // no argument else if (ppSelect.first == std::string("Random")) // no argument
{ {
select = new eoRandomSelect<EOT>; select = new eoRandomSelect<EOT>;
} }
else else
{ {
string stmp = string("Invalid selection: ") + ppSelect.first; std::string stmp = std::string("Invalid selection: ") + ppSelect.first;
throw runtime_error(stmp.c_str()); throw std::runtime_error(stmp.c_str());
} }
_state.storeFunctor(select); _state.storeFunctor(select);
@ -188,62 +188,62 @@ eoAlgo<EOT> & do_make_algo_scalar(eoParser& _parser, eoState& _state, eoEvalFunc
// the replacement // the replacement
eoValueParam<eoParamParamType>& replacementParam = _parser.createParam(eoParamParamType("Comma"), "replacement", "Replacement: Comma, Plus or EPTour(T), SSGAWorst, SSGADet(T), SSGAStoch(t)", 'R', "Evolution Engine"); eoValueParam<eoParamParamType>& replacementParam = _parser.createParam(eoParamParamType("Comma"), "replacement", "Replacement: Comma, Plus or EPTour(T), SSGAWorst, SSGADet(T), SSGAStoch(t)", 'R', "Evolution Engine");
eoParamParamType & ppReplace = replacementParam.value(); // pair<string,vector<string> > eoParamParamType & ppReplace = replacementParam.value(); // std::pair<std::string,std::vector<std::string> >
eoReplacement<EOT>* replace ; eoReplacement<EOT>* replace ;
if (ppReplace.first == string("Comma")) // Comma == generational if (ppReplace.first == std::string("Comma")) // Comma == generational
{ {
replace = new eoCommaReplacement<EOT>; replace = new eoCommaReplacement<EOT>;
} }
else if (ppReplace.first == string("Plus")) else if (ppReplace.first == std::string("Plus"))
{ {
replace = new eoPlusReplacement<EOT>; replace = new eoPlusReplacement<EOT>;
} }
else if (ppReplace.first == string("EPTour")) else if (ppReplace.first == std::string("EPTour"))
{ {
unsigned detSize; unsigned detSize;
if (!ppReplace.second.size()) // no parameter added if (!ppReplace.second.size()) // no parameter added
{ {
cerr << "WARNING, no parameter passed to EPTour, using 6" << endl; std::cerr << "WARNING, no parameter passed to EPTour, using 6" << std::endl;
detSize = 6; detSize = 6;
// put back in parameter for consistency (and status file) // put back in parameter for consistency (and status file)
ppReplace.second.push_back(string("6")); ppReplace.second.push_back(std::string("6"));
} }
else // parameter passed by user as EPTour(T) else // parameter passed by user as EPTour(T)
detSize = atoi(ppSelect.second[0].c_str()); detSize = atoi(ppSelect.second[0].c_str());
replace = new eoEPReplacement<EOT>(detSize); replace = new eoEPReplacement<EOT>(detSize);
} }
else if (ppReplace.first == string("SSGAWorst")) else if (ppReplace.first == std::string("SSGAWorst"))
{ {
replace = new eoSSGAWorseReplacement<EOT>; replace = new eoSSGAWorseReplacement<EOT>;
} }
else if (ppReplace.first == string("SSGADet")) else if (ppReplace.first == std::string("SSGADet"))
{ {
unsigned detSize; unsigned detSize;
if (!ppReplace.second.size()) // no parameter added if (!ppReplace.second.size()) // no parameter added
{ {
cerr << "WARNING, no parameter passed to SSGADet, using 2" << endl; std::cerr << "WARNING, no parameter passed to SSGADet, using 2" << std::endl;
detSize = 2; detSize = 2;
// put back in parameter for consistency (and status file) // put back in parameter for consistency (and status file)
ppReplace.second.push_back(string("2")); ppReplace.second.push_back(std::string("2"));
} }
else // parameter passed by user as SSGADet(T) else // parameter passed by user as SSGADet(T)
detSize = atoi(ppSelect.second[0].c_str()); detSize = atoi(ppSelect.second[0].c_str());
replace = new eoSSGADetTournamentReplacement<EOT>(detSize); replace = new eoSSGADetTournamentReplacement<EOT>(detSize);
} }
else if (ppReplace.first == string("SSGAStoch")) else if (ppReplace.first == std::string("SSGAStoch"))
{ {
double p; double p;
if (!ppReplace.second.size()) // no parameter added if (!ppReplace.second.size()) // no parameter added
{ {
cerr << "WARNING, no parameter passed to SSGAStoch, using 1" << endl; std::cerr << "WARNING, no parameter passed to SSGAStoch, using 1" << std::endl;
p = 1; p = 1;
// put back in parameter for consistency (and status file) // put back in parameter for consistency (and status file)
ppReplace.second.push_back(string("1")); ppReplace.second.push_back(std::string("1"));
} }
else // parameter passed by user as SSGADet(T) else // parameter passed by user as SSGADet(T)
p = atof(ppSelect.second[0].c_str()); p = atof(ppSelect.second[0].c_str());
@ -252,8 +252,8 @@ eoAlgo<EOT> & do_make_algo_scalar(eoParser& _parser, eoState& _state, eoEvalFunc
} }
else else
{ {
string stmp = string("Invalid replacement: ") + ppReplace.first; std::string stmp = std::string("Invalid replacement: ") + ppReplace.first;
throw runtime_error(stmp.c_str()); throw std::runtime_error(stmp.c_str());
} }
_state.storeFunctor(replace); _state.storeFunctor(replace);

26
eo/src/do/make_checkpoint.h
View file

@ -66,7 +66,7 @@ eoCheckPoint<EOT>& do_make_checkpoint(eoParser& _parser, eoState& _state, eoEval
checkpoint->add(*generationCounter); checkpoint->add(*generationCounter);
// dir for DISK output // dir for DISK output
eoValueParam<string>& dirNameParam = _parser.createParam(string("Res"), "resDir", "Directory to store DISK outputs", '\0', "Output - Disk"); eoValueParam<std::string>& dirNameParam = _parser.createParam(std::string("Res"), "resDir", "Directory to store DISK outputs", '\0', "Output - Disk");
// shoudl we empty it if exists // shoudl we empty it if exists
eoValueParam<bool>& eraseParam = _parser.createParam(true, "eraseDir", "erase files in dirName if any", '\0', "Output - Disk"); eoValueParam<bool>& eraseParam = _parser.createParam(true, "eraseDir", "erase files in dirName if any", '\0', "Output - Disk");
bool dirOK = false; // not tested yet bool dirOK = false; // not tested yet
@ -79,9 +79,9 @@ eoCheckPoint<EOT>& do_make_checkpoint(eoParser& _parser, eoState& _state, eoEval
* *
* eoBestFitnessStat : best value in pop - type EOT::Fitness * eoBestFitnessStat : best value in pop - type EOT::Fitness
* eoAverageStat : average value in pop - type EOT::Fitness * eoAverageStat : average value in pop - type EOT::Fitness
* eoSecondMomentStat: average + stdev - type pair<double, double> * eoSecondMomentStat: average + stdev - type std::pair<double, double>
* eoSortedPopStat : whole population - type string (!!) * eoSortedPopStat : whole population - type std::string (!!)
* eoScalarFitnessStat: the fitnesses - type vector<double> * eoScalarFitnessStat: the fitnesses - type std::vector<double>
*/ */
// Best fitness in population // Best fitness in population
@ -188,9 +188,9 @@ eoCheckPoint<EOT>& do_make_checkpoint(eoParser& _parser, eoState& _state, eoEval
if (fileBestParam.value()) // A file monitor for best & secondMoment if (fileBestParam.value()) // A file monitor for best & secondMoment
{ {
#ifdef _MSVC #ifdef _MSVC
string stmp = dirNameParam.value() + "\best.xg"; std::string stmp = dirNameParam.value() + "\best.xg";
#else #else
string stmp = dirNameParam.value() + "/best.xg"; std::string stmp = dirNameParam.value() + "/best.xg";
#endif #endif
eoFileMonitor *fileMonitor = new eoFileMonitor(stmp); eoFileMonitor *fileMonitor = new eoFileMonitor(stmp);
// save and give to checkpoint // save and give to checkpoint
@ -201,7 +201,7 @@ eoCheckPoint<EOT>& do_make_checkpoint(eoParser& _parser, eoState& _state, eoEval
fileMonitor->add(_eval); fileMonitor->add(_eval);
if (tCounter) // we want the time as well if (tCounter) // we want the time as well
{ {
// cout << "On met timecounter\n"; // std::cout << "On met timecounter\n";
fileMonitor->add(*tCounter); fileMonitor->add(*tCounter);
} }
fileMonitor->add(*bestStat); fileMonitor->add(*bestStat);
@ -211,7 +211,7 @@ eoCheckPoint<EOT>& do_make_checkpoint(eoParser& _parser, eoState& _state, eoEval
#if !defined(NO_GNUPLOT) #if !defined(NO_GNUPLOT)
if (plotBestParam.value()) // an eoGnuplot1DMonitor for best & average if (plotBestParam.value()) // an eoGnuplot1DMonitor for best & average
{ {
string stmp = dirNameParam.value() + "/gnu_best.xg"; std::string stmp = dirNameParam.value() + "/gnu_best.xg";
eoGnuplot1DMonitor *gnuMonitor = new eoGnuplot1DMonitor(stmp,minimizing_fitness<EOT>()); eoGnuplot1DMonitor *gnuMonitor = new eoGnuplot1DMonitor(stmp,minimizing_fitness<EOT>());
// save and give to checkpoint // save and give to checkpoint
_state.storeFunctor(gnuMonitor); _state.storeFunctor(gnuMonitor);
@ -236,7 +236,7 @@ eoCheckPoint<EOT>& do_make_checkpoint(eoParser& _parser, eoState& _state, eoEval
// a gnuplot-based monitor for snapshots: needs a dir name // a gnuplot-based monitor for snapshots: needs a dir name
eoGnuplot1DSnapshot *fitSnapshot = new eoGnuplot1DSnapshot(dirNameParam.value()); eoGnuplot1DSnapshot *fitSnapshot = new eoGnuplot1DSnapshot(dirNameParam.value());
_state.storeFunctor(fitSnapshot); _state.storeFunctor(fitSnapshot);
// add any stat that is a vector<double> to it // add any stat that is a std::vector<double> to it
fitSnapshot->add(*fitStat); fitSnapshot->add(*fitStat);
// and of course add it to the checkpoint // and of course add it to the checkpoint
checkpoint->add(*fitSnapshot); checkpoint->add(*fitSnapshot);
@ -259,9 +259,9 @@ eoCheckPoint<EOT>& do_make_checkpoint(eoParser& _parser, eoState& _state, eoEval
unsigned freq = (saveFrequencyParam.value()>0 ? saveFrequencyParam.value() : UINT_MAX ); unsigned freq = (saveFrequencyParam.value()>0 ? saveFrequencyParam.value() : UINT_MAX );
#ifdef _MSVC #ifdef _MSVC
string stmp = dirNameParam.value() + "\generations"; std::string stmp = dirNameParam.value() + "\generations";
#else #else
string stmp = dirNameParam.value() + "/generations"; std::string stmp = dirNameParam.value() + "/generations";
#endif #endif
eoCountedStateSaver *stateSaver1 = new eoCountedStateSaver(freq, _state, stmp); eoCountedStateSaver *stateSaver1 = new eoCountedStateSaver(freq, _state, stmp);
_state.storeFunctor(stateSaver1); _state.storeFunctor(stateSaver1);
@ -277,9 +277,9 @@ eoCheckPoint<EOT>& do_make_checkpoint(eoParser& _parser, eoState& _state, eoEval
dirOK = testDirRes(dirNameParam.value(), eraseParam.value()); // TRUE dirOK = testDirRes(dirNameParam.value(), eraseParam.value()); // TRUE
#ifdef _MSVC #ifdef _MSVC
string stmp = dirNameParam.value() + "\time"; std::string stmp = dirNameParam.value() + "\time";
#else #else
string stmp = dirNameParam.value() + "/time"; std::string stmp = dirNameParam.value() + "/time";
#endif #endif
eoTimedStateSaver *stateSaver2 = new eoTimedStateSaver(saveTimeIntervalParam.value(), _state, stmp); eoTimedStateSaver *stateSaver2 = new eoTimedStateSaver(saveTimeIntervalParam.value(), _state, stmp);
_state.storeFunctor(stateSaver2); _state.storeFunctor(stateSaver2);

18
eo/src/do/make_checkpoint_FDC.h
View file

@ -62,7 +62,7 @@ eoCheckPoint<EOT>& do_make_checkpoint(eoParser& _parser, eoState& _state, eoEval
_state.storeFunctor(increment); _state.storeFunctor(increment);
// dir for DISK output // dir for DISK output
eoValueParam<string>& dirNameParam = _parser.createParam(string("Res"), "resDir", "Directory to store DISK outputs", '\0', "Output - Disk"); eoValueParam<std::string>& dirNameParam = _parser.createParam(std::string("Res"), "resDir", "Directory to store DISK outputs", '\0', "Output - Disk");
// shoudl we empty it if exists // shoudl we empty it if exists
eoValueParam<bool>& eraseParam = _parser.createParam(false, "eraseDir", "erase files in dirName if any", '\0', "Output - Disk"); eoValueParam<bool>& eraseParam = _parser.createParam(false, "eraseDir", "erase files in dirName if any", '\0', "Output - Disk");
bool dirOK = false; // not tested yet bool dirOK = false; // not tested yet
@ -75,9 +75,9 @@ eoCheckPoint<EOT>& do_make_checkpoint(eoParser& _parser, eoState& _state, eoEval
* *
* eoBestFitnessStat : best value in pop - type EOT::Fitness * eoBestFitnessStat : best value in pop - type EOT::Fitness
* eoAverageStat : average value in pop - type EOT::Fitness * eoAverageStat : average value in pop - type EOT::Fitness
* eoSecondMomentStat: average + stdev - type pair<double, double> * eoSecondMomentStat: average + stdev - type std::pair<double, double>
* eoSortedPopStat : whole population - type string (!!) * eoSortedPopStat : whole population - type std::string (!!)
* eoScalarFitnessStat: the fitnesses - type vector<double> * eoScalarFitnessStat: the fitnesses - type std::vector<double>
* eoDFCSTat : FDC wrt best in pop or absolute best - type double * eoDFCSTat : FDC wrt best in pop or absolute best - type double
* requires an eoDistance. See eoFDCStat.h * requires an eoDistance. See eoFDCStat.h
* also computes all elements for the FDC scatter plot * also computes all elements for the FDC scatter plot
@ -199,7 +199,7 @@ eoCheckPoint<EOT>& do_make_checkpoint(eoParser& _parser, eoState& _state, eoEval
if (fileBestParam.value()) // A file monitor for best & secondMoment if (fileBestParam.value()) // A file monitor for best & secondMoment
{ {
string stmp = dirNameParam.value() + "/best.xg"; std::string stmp = dirNameParam.value() + "/best.xg";
eoFileMonitor *fileMonitor = new eoFileMonitor(stmp); eoFileMonitor *fileMonitor = new eoFileMonitor(stmp);
// save and give to checkpoint // save and give to checkpoint
_state.storeFunctor(fileMonitor); _state.storeFunctor(fileMonitor);
@ -213,7 +213,7 @@ eoCheckPoint<EOT>& do_make_checkpoint(eoParser& _parser, eoState& _state, eoEval
if (plotBestParam.value()) // an eoGnuplot1DMonitor for best & average if (plotBestParam.value()) // an eoGnuplot1DMonitor for best & average
{ {
string stmp = dirNameParam.value() + "_gnu_best.xg"; std::string stmp = dirNameParam.value() + "_gnu_best.xg";
eoGnuplot1DMonitor *gnuMonitor = new eoGnuplot1DMonitor(stmp,minimizing_fitness<EOT>()); eoGnuplot1DMonitor *gnuMonitor = new eoGnuplot1DMonitor(stmp,minimizing_fitness<EOT>());
// save and give to checkpoint // save and give to checkpoint
_state.storeFunctor(gnuMonitor); _state.storeFunctor(gnuMonitor);
@ -250,7 +250,7 @@ eoCheckPoint<EOT>& do_make_checkpoint(eoParser& _parser, eoState& _state, eoEval
// a gnuplot-based monitor for snapshots: needs a dir name // a gnuplot-based monitor for snapshots: needs a dir name
eoGnuplot1DSnapshot *fitSnapshot = new eoGnuplot1DSnapshot(dirNameParam.value()); eoGnuplot1DSnapshot *fitSnapshot = new eoGnuplot1DSnapshot(dirNameParam.value());
_state.storeFunctor(fitSnapshot); _state.storeFunctor(fitSnapshot);
// add any stat that is a vector<double> to it // add any stat that is a std::vector<double> to it
fitSnapshot->add(*fitStat); fitSnapshot->add(*fitStat);
// and of course add it to the checkpoint // and of course add it to the checkpoint
checkpoint->add(*fitSnapshot); checkpoint->add(*fitSnapshot);
@ -271,7 +271,7 @@ eoCheckPoint<EOT>& do_make_checkpoint(eoParser& _parser, eoState& _state, eoEval
dirOK = testDirRes(dirNameParam.value(), eraseParam.value()); // TRUE dirOK = testDirRes(dirNameParam.value(), eraseParam.value()); // TRUE
unsigned freq = (saveFrequencyParam.value()>0 ? saveFrequencyParam.value() : UINT_MAX ); unsigned freq = (saveFrequencyParam.value()>0 ? saveFrequencyParam.value() : UINT_MAX );
string stmp = dirNameParam.value() + "/generations"; std::string stmp = dirNameParam.value() + "/generations";
eoCountedStateSaver *stateSaver1 = new eoCountedStateSaver(freq, _state, stmp); eoCountedStateSaver *stateSaver1 = new eoCountedStateSaver(freq, _state, stmp);
_state.storeFunctor(stateSaver1); _state.storeFunctor(stateSaver1);
checkpoint->add(*stateSaver1); checkpoint->add(*stateSaver1);
@ -285,7 +285,7 @@ eoCheckPoint<EOT>& do_make_checkpoint(eoParser& _parser, eoState& _state, eoEval
if (! dirOK ) if (! dirOK )
dirOK = testDirRes(dirNameParam.value(), eraseParam.value()); // TRUE dirOK = testDirRes(dirNameParam.value(), eraseParam.value()); // TRUE
string stmp = dirNameParam.value() + "/time"; std::string stmp = dirNameParam.value() + "/time";
eoTimedStateSaver *stateSaver2 = new eoTimedStateSaver(saveTimeIntervalParam.value(), _state, stmp); eoTimedStateSaver *stateSaver2 = new eoTimedStateSaver(saveTimeIntervalParam.value(), _state, stmp);
_state.storeFunctor(stateSaver2); _state.storeFunctor(stateSaver2);
checkpoint->add(*stateSaver2); checkpoint->add(*stateSaver2);

32
eo/src/do/make_checkpoint_pareto.h
View file

@ -69,7 +69,7 @@ eoCheckPoint<EOT>& do_make_checkpoint_pareto(eoParser& _parser, eoState& _state,
checkpoint.add(increment); checkpoint.add(increment);
// dir for DISK output // dir for DISK output
string & dirName = _parser.getORcreateParam(string("Res"), "resDir", "Directory to store DISK outputs", '\0', "Output - Disk").value(); std::string & dirName = _parser.getORcreateParam(std::string("Res"), "resDir", "Directory to store DISK outputs", '\0', "Output - Disk").value();
// shoudl we empty it if exists // shoudl we empty it if exists
eoValueParam<bool>& eraseParam = _parser.createParam(true, "eraseDir", "erase files in dirName if any", '\0', "Output - Disk"); eoValueParam<bool>& eraseParam = _parser.createParam(true, "eraseDir", "erase files in dirName if any", '\0', "Output - Disk");
bool dirOK = false; // not tested yet bool dirOK = false; // not tested yet
@ -80,22 +80,22 @@ eoCheckPoint<EOT>& do_make_checkpoint_pareto(eoParser& _parser, eoState& _state,
/** /**
* existing stats for Pareto as of today, Jan. 31. 2002 * existing stats for Pareto as of today, Jan. 31. 2002
* *
* eoSortedPopStat : whole population - type string (!!) * eoSortedPopStat : whole population - type std::string (!!)
*/ */
eoValueParam<eoParamParamType>& fPlotParam = _parser.createParam(eoParamParamType("1(0,1)"), "frontFileFrequency", "File save frequency in objective spaces (pairs of comma-separated objectives in 1 single parentheses pair)", '\0', "Output - Disk"); eoValueParam<eoParamParamType>& fPlotParam = _parser.createParam(eoParamParamType("1(0,1)"), "frontFileFrequency", "File save frequency in objective spaces (std::pairs of comma-separated objectives in 1 single parentheses std::pair)", '\0', "Output - Disk");
#if !defined(NO_GNUPLOT) #if !defined(NO_GNUPLOT)
bool boolGnuplot = _parser.createParam(false, "plotFront", "Objective plots (requires corresponding files - see frontFileFrequency", '\0', "Output - Graphical").value(); bool boolGnuplot = _parser.createParam(false, "plotFront", "Objective plots (requires corresponding files - see frontFileFrequency", '\0', "Output - Graphical").value();
#endif #endif
eoParamParamType & fPlot = fPlotParam.value(); // pair<string,vector<string> > eoParamParamType & fPlot = fPlotParam.value(); // std::pair<std::string,std::vector<std::string> >
unsigned frequency = atoi(fPlot.first.c_str()); unsigned frequency = atoi(fPlot.first.c_str());
if (frequency) // something to plot if (frequency) // something to plot
{ {
unsigned nbPlot = fPlot.second.size(); unsigned nbPlot = fPlot.second.size();
if ( nbPlot % 2 ) // odd! if ( nbPlot % 2 ) // odd!
throw runtime_error("Odd number of front description in make_checkpoint_pareto"); throw std::runtime_error("Odd number of front description in make_checkpoint_pareto");
// only create the necessary stats // only create the necessary stats
std::vector<bool> bStat(nObj, false); // track of who's already there std::vector<bool> bStat(nObj, false); // track of who's already there
@ -110,8 +110,8 @@ eoCheckPoint<EOT>& do_make_checkpoint_pareto(eoParser& _parser, eoState& _state,
if (!bStat[obj1]) // not already there: create it if (!bStat[obj1]) // not already there: create it
{ {
char s[1024]; char s[1024];
ostrstream os(s, 1022); std::ostrstream os(s, 1022);
os << "Obj. " << obj1 << ends; os << "Obj. " << obj1 << std::ends;
fStat = new eoMOFitnessStat<EOT>(obj1, s); fStat = new eoMOFitnessStat<EOT>(obj1, s);
_state.storeFunctor(fStat); _state.storeFunctor(fStat);
bStat[obj1]=true; bStat[obj1]=true;
@ -121,8 +121,8 @@ eoCheckPoint<EOT>& do_make_checkpoint_pareto(eoParser& _parser, eoState& _state,
if (!bStat[obj2]) // not already there: create it if (!bStat[obj2]) // not already there: create it
{ {
char s2[1024]; char s2[1024];
ostrstream os2(s2, 1022); std::ostrstream os2(s2, 1022);
os2 << "Obj. " << obj2 << ends; os2 << "Obj. " << obj2 << std::ends;
fStat = new eoMOFitnessStat<EOT>(obj2, s2); fStat = new eoMOFitnessStat<EOT>(obj2, s2);
_state.storeFunctor(fStat); _state.storeFunctor(fStat);
bStat[obj2]=true; bStat[obj2]=true;
@ -132,8 +132,8 @@ eoCheckPoint<EOT>& do_make_checkpoint_pareto(eoParser& _parser, eoState& _state,
// then the fileSnapshots // then the fileSnapshots
char s3[1024]; char s3[1024];
ostrstream os3(s3, 1022); std::ostrstream os3(s3, 1022);
os3 << "Front." << obj1 << "." << obj2 << "." << ends; os3 << "Front." << obj1 << "." << obj2 << "." << std::ends;
eoFileSnapshot & snapshot = _state.storeFunctor(new eoFileSnapshot & snapshot = _state.storeFunctor(new
eoFileSnapshot(dirName, frequency, s3 ) ); eoFileSnapshot(dirName, frequency, s3 ) );
@ -160,7 +160,7 @@ eoCheckPoint<EOT>& do_make_checkpoint_pareto(eoParser& _parser, eoState& _state,
eoSortedPopStat<EOT> * popStat; eoSortedPopStat<EOT> * popStat;
if ( printPop ) // we do want pop dump if ( printPop ) // we do want pop dump
{ {
cout << "On cree printpop\n"; std::cout << "On cree printpop\n";
popStat = & _state.storeFunctor(new eoSortedPopStat<EOT>); popStat = & _state.storeFunctor(new eoSortedPopStat<EOT>);
// add it to the checkpoint // add it to the checkpoint
checkpoint.add(*popStat); checkpoint.add(*popStat);
@ -205,9 +205,9 @@ eoCheckPoint<EOT>& do_make_checkpoint_pareto(eoParser& _parser, eoState& _state,
unsigned freq = (saveFrequencyParam.value()>0 ? saveFrequencyParam.value() : UINT_MAX ); unsigned freq = (saveFrequencyParam.value()>0 ? saveFrequencyParam.value() : UINT_MAX );
#ifdef _MSVC #ifdef _MSVC
string stmp = dirName + "\generations"; std::string stmp = dirName + "\generations";
#else #else
string stmp = dirName + "/generations"; std::string stmp = dirName + "/generations";
#endif #endif
eoCountedStateSaver *stateSaver1 = new eoCountedStateSaver(freq, _state, stmp); eoCountedStateSaver *stateSaver1 = new eoCountedStateSaver(freq, _state, stmp);
_state.storeFunctor(stateSaver1); _state.storeFunctor(stateSaver1);
@ -223,9 +223,9 @@ eoCheckPoint<EOT>& do_make_checkpoint_pareto(eoParser& _parser, eoState& _state,
dirOK = testDirRes(dirName, eraseParam.value()); // TRUE dirOK = testDirRes(dirName, eraseParam.value()); // TRUE
#ifdef _MSVC #ifdef _MSVC
string stmp = dirName + "\time"; std::string stmp = dirName + "\time";
#else #else
string stmp = dirName + "/time"; std::string stmp = dirName + "/time";
#endif #endif
eoTimedStateSaver *stateSaver2 = new eoTimedStateSaver(saveTimeIntervalParam.value(), _state, stmp); eoTimedStateSaver *stateSaver2 = new eoTimedStateSaver(saveTimeIntervalParam.value(), _state, stmp);
_state.storeFunctor(stateSaver2); _state.storeFunctor(stateSaver2);

2
eo/src/do/make_continue.h
View file

@ -146,7 +146,7 @@ eoContinue<Indi> & do_make_continue(eoParser& _parser, eoState& _state, eoEvalFu
// now check that there is at least one! // now check that there is at least one!
if (!continuator) if (!continuator)
throw runtime_error("You MUST provide a stopping criterion"); throw std::runtime_error("You MUST provide a stopping criterion");
// OK, it's there: store in the eoState // OK, it's there: store in the eoState
_state.storeFunctor(continuator); _state.storeFunctor(continuator);

2
eo/src/do/make_continue_pareto.h
View file

@ -97,7 +97,7 @@ eoContinue<Indi> & do_make_continue_pareto(eoParser& _parser, eoState& _state, e
// now check that there is at least one! // now check that there is at least one!
if (!continuator) if (!continuator)
throw runtime_error("You MUST provide a stopping criterion"); throw std::runtime_error("You MUST provide a stopping criterion");
// OK, it's there: store in the eoState // OK, it's there: store in the eoState
_state.storeFunctor(continuator); _state.storeFunctor(continuator);

28
eo/src/do/make_general_replacement.h
View file

@ -47,64 +47,64 @@ eoReduce<EOT> & decode_reduce(eoParamParamType & _ppReduce, eoState & _state)
eoReduce<EOT> * ptReduce; eoReduce<EOT> * ptReduce;
// ---------- Deterministic // ---------- Deterministic
if (_ppReduce.first == string("Deterministic")) if (_ppReduce.first == std::string("Deterministic"))
{ {
ptReduce = new eoTruncate<EOT>; ptReduce = new eoTruncate<EOT>;
} }
// ---------- EP // ---------- EP
else if (_ppReduce.first == string("EP")) else if (_ppReduce.first == std::string("EP"))
{ {
if (!_ppReduce.second.size()) // no parameter added if (!_ppReduce.second.size()) // no parameter added
{ {
cerr << "WARNING, no parameter passed to EP, using 6" << endl; std::cerr << "WARNING, no parameter passed to EP, using 6" << std::endl;
detSize = 6; detSize = 6;
// put back 6 in parameter for consistency (and status file) // put back 6 in parameter for consistency (and status file)
_ppReduce.second.push_back(string("6")); _ppReduce.second.push_back(std::string("6"));
} }
else // parameter passed by user as EP(T) else // parameter passed by user as EP(T)
detSize = atoi(_ppReduce.second[0].c_str()); detSize = atoi(_ppReduce.second[0].c_str());
ptReduce = new eoEPReduce<EOT>(detSize); ptReduce = new eoEPReduce<EOT>(detSize);
} }
// ---------- DetTour // ---------- DetTour
else if (_ppReduce.first == string("DetTour")) else if (_ppReduce.first == std::string("DetTour"))
{ {
if (!_ppReduce.second.size()) // no parameter added if (!_ppReduce.second.size()) // no parameter added
{ {
cerr << "WARNING, no parameter passed to DetTour, using 2" << endl; std::cerr << "WARNING, no parameter passed to DetTour, using 2" << std::endl;
detSize = 2; detSize = 2;
// put back 2 in parameter for consistency (and status file) // put back 2 in parameter for consistency (and status file)
_ppReduce.second.push_back(string("2")); _ppReduce.second.push_back(std::string("2"));
} }
else // parameter passed by user as DetTour(T) else // parameter passed by user as DetTour(T)
detSize = atoi(_ppReduce.second[0].c_str()); detSize = atoi(_ppReduce.second[0].c_str());
ptReduce = new eoDetTournamentTruncate<EOT>(detSize); ptReduce = new eoDetTournamentTruncate<EOT>(detSize);
} }
else if (_ppReduce.first == string("StochTour")) else if (_ppReduce.first == std::string("StochTour"))
{ {
double p; double p;
if (!_ppReduce.second.size()) // no parameter added if (!_ppReduce.second.size()) // no parameter added
{ {
cerr << "WARNING, no parameter passed to StochTour, using 1" << endl; std::cerr << "WARNING, no parameter passed to StochTour, using 1" << std::endl;
p = 1; p = 1;
// put back p in parameter for consistency (and status file) // put back p in parameter for consistency (and status file)
_ppReduce.second.push_back(string("1")); _ppReduce.second.push_back(std::string("1"));
} }
else // parameter passed by user as DetTour(T) else // parameter passed by user as DetTour(T)
{ {
p = atof(_ppReduce.second[0].c_str()); p = atof(_ppReduce.second[0].c_str());
if ( (p<=0.5) || (p>1) ) if ( (p<=0.5) || (p>1) )
throw runtime_error("Stochastic tournament size should be in [0.5,1]"); throw std::runtime_error("Stochastic tournament size should be in [0.5,1]");
} }
ptReduce = new eoStochTournamentTruncate<EOT>(p); ptReduce = new eoStochTournamentTruncate<EOT>(p);
} }
else if (_ppReduce.first == string("Uniform")) else if (_ppReduce.first == std::string("Uniform"))
{ {
ptReduce = new eoRandomReduce<EOT>; ptReduce = new eoRandomReduce<EOT>;
} }
else // no known reduction entered else // no known reduction entered
{ {
throw runtime_error("Unknown reducer: " + _ppReduce.first); throw std::runtime_error("Unknown reducer: " + _ppReduce.first);
} }
// all done, stores and return a reference // all done, stores and return a reference
_state.storeFunctor(ptReduce); _state.storeFunctor(ptReduce);
@ -117,7 +117,7 @@ eoReduce<EOT> & decode_reduce(eoParamParamType & _ppReduce, eoState & _state)
* *
* eoHowMany _elite the number of elite parents (0 = no elitism) * eoHowMany _elite the number of elite parents (0 = no elitism)
* see below * see below
* bool _strongElitism if elite > 0, string elitism or weak elitism * bool _strongElitism if elite > 0, std::string elitism or weak elitism
* strong = elite parents survive, whatever the offspring * strong = elite parents survive, whatever the offspring
* weak - elite patents compete AFTER replacement with best offspring * weak - elite patents compete AFTER replacement with best offspring
* eoHowMany _surviveParents number of parents after parents recuction * eoHowMany _surviveParents number of parents after parents recuction

2
eo/src/do/make_pop.h
View file

@ -58,7 +58,7 @@ eoPop<EOT>& do_make_pop(eoParser & _parser, eoState& _state, eoInit<EOT> & _ini
// create an empty pop and let the state handle the memory // create an empty pop and let the state handle the memory
eoPop<EOT>& pop = _state.takeOwnership(eoPop<EOT>()); eoPop<EOT>& pop = _state.takeOwnership(eoPop<EOT>());
eoValueParam<string>& loadNameParam = _parser.createParam(string(""), "Load","A save file to restart from",'L', "Persistence" ); eoValueParam<std::string>& loadNameParam = _parser.createParam(std::string(""), "Load","A save file to restart from",'L', "Persistence" );
eoValueParam<bool> & recomputeFitnessParam = _parser.createParam(false, "recomputeFitness", "Recompute the fitness after re-loading the pop.?", 'r', "Persistence" ); eoValueParam<bool> & recomputeFitnessParam = _parser.createParam(false, "recomputeFitness", "Recompute the fitness after re-loading the pop.?", 'r', "Persistence" );
if (loadNameParam.value() != "") // something to load if (loadNameParam.value() != "") // something to load

8
eo/src/eoCloneOps.h
View file

@ -18,7 +18,7 @@
Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
Contact: todos@geneura.ugr.es, http://geneura.ugr.es Contact: todos@geneura.ugr.es, http://geneura.ugr.es
CVS Info: $Date: 2001-04-12 16:46:55 $ $Header: /home/nojhan/dev/eodev/eodev_cvs/eo/src/eoCloneOps.h,v 1.1 2001-04-12 16:46:55 evomarc Exp $ $Author: evomarc $ CVS Info: $Date: 2003-02-27 19:26:09 $ $Header: /home/nojhan/dev/eodev/eodev_cvs/eo/src/eoCloneOps.h,v 1.2 2003-02-27 19:26:09 okoenig Exp $ $Author: okoenig $
*/ */
//----------------------------------------------------------------------------- //-----------------------------------------------------------------------------
@ -46,7 +46,7 @@ class eoMonCloneOp: public eoMonOp<EOT>
public: public:
/// Ctor /// Ctor
eoMonCloneOp() : eoMonOp<EOT>() {} eoMonCloneOp() : eoMonOp<EOT>() {}
virtual string className() const {return "eoMonCloneOp";} virtual std::string className() const {return "eoMonCloneOp";}
virtual bool operator()(EOT&){return false;} virtual bool operator()(EOT&){return false;}
}; };
@ -59,7 +59,7 @@ class eoBinCloneOp: public eoBinOp<EOT>
public: public:
/// Ctor /// Ctor
eoBinCloneOp() : eoBinOp<EOT>() {} eoBinCloneOp() : eoBinOp<EOT>() {}
virtual string className() const {return "eoBinCloneOp";} virtual std::string className() const {return "eoBinCloneOp";}
virtual bool operator()(EOT&, const EOT&){return false;} virtual bool operator()(EOT&, const EOT&){return false;}
}; };
@ -71,7 +71,7 @@ class eoQuadCloneOp: public eoQuadOp<EOT>
public: public:
/// Ctor /// Ctor
eoQuadCloneOp():eoQuadOp<EOT>() {} eoQuadCloneOp():eoQuadOp<EOT>() {}
virtual string className() const {return "eoQuadCloneOp";} virtual std::string className() const {return "eoQuadCloneOp";}
virtual bool operator()(EOT& , EOT& ) {return false;} virtual bool operator()(EOT& , EOT& ) {return false;}
}; };

2
eo/src/eoCombinedContinue.h
View file

@ -31,7 +31,7 @@
Combined continuators - logical AND: Combined continuators - logical AND:
Continues until one of the embedded continuators says halt! Continues until one of the embedded continuators says halt!
20/11/00 MS: Changed the 2-continuator construct to a vector<eoContinue<EOT> > 20/11/00 MS: Changed the 2-continuator construct to a std::vector<eoContinue<EOT> >
to be consistent with other Combined constructs to be consistent with other Combined constructs
and allow to easily handle more than 2 continuators and allow to easily handle more than 2 continuators

2
eo/src/eoCtrlCContinue.h
View file

@ -51,7 +51,7 @@ public:
{ {
// First checks that no other eoCtrlCContinue does exist // First checks that no other eoCtrlCContinue does exist
if (existCtrlCContinue) if (existCtrlCContinue)
throw runtime_error("A signal handler for Ctrl C is already defined!\n"); throw std::runtime_error("A signal handler for Ctrl C is already defined!\n");
signal( SIGINT, signal_handler ); signal( SIGINT, signal_handler );
signal( SIGQUIT, signal_handler ); signal( SIGQUIT, signal_handler );
existCtrlCContinue = true; existCtrlCContinue = true;

2
eo/src/eoDetTournamentSelect.h
View file

@ -50,7 +50,7 @@ template <class EOT> class eoDetTournamentSelect: public eoSelectOne<EOT>
eoDetTournamentSelect(unsigned _tSize = 2 ):eoSelectOne<EOT>(), tSize(_tSize) { eoDetTournamentSelect(unsigned _tSize = 2 ):eoSelectOne<EOT>(), tSize(_tSize) {
// consistency check // consistency check
if (tSize < 2) { if (tSize < 2) {
cout << "Warning, Tournament size should be >= 2\nAdjusted to 2\n"; std::cout << "Warning, Tournament size should be >= 2\nAdjusted to 2\n";
tSize = 2; tSize = 2;
} }
} }

16
eo/src/eoDominanceMap.h
View file

@ -31,7 +31,7 @@
#include <eoPop.h> #include <eoPop.h>
/** /**
eoDominanceMap, utility class to calculate and maintain a map (vector<vector<bool> >) of pareto dominance statistics. eoDominanceMap, utility class to calculate and maintain a map (std::vector<std::vector<bool> >) of pareto dominance statistics.
It is set up such that It is set up such that
@ -115,12 +115,12 @@ class eoDominanceMap : public eoUF<const eoPop<EoType>&, void>, public std::vect
/** /**
For all elements, returns the no. of elements that dominate the element For all elements, returns the no. of elements that dominate the element
Thus: lower is better (and 0 is the front). Thus: lower is better (and 0 is the front).
It returns a vector<double> cuz that It returns a std::vector<double> cuz that
makes subsequent manipulation that much easier makes subsequent manipulation that much easier
*/ */
vector<double> sum_dominators() const std::vector<double> sum_dominators() const
{ {
vector<double> result(size(), 0.0); std::vector<double> result(size(), 0.0);
for (unsigned i = 0; i < size(); ++i) for (unsigned i = 0; i < size(); ++i)
{ {
@ -137,12 +137,12 @@ class eoDominanceMap : public eoUF<const eoPop<EoType>&, void>, public std::vect
/** /**
For all elements, returns the number of elements that the element dominates For all elements, returns the number of elements that the element dominates
Thus: higher is better Thus: higher is better
It returns a vector<double> cuz that It returns a std::vector<double> cuz that
makes subsequent manipulation that much easier makes subsequent manipulation that much easier
*/ */
vector<double> sum_dominants() const std::vector<double> sum_dominants() const
{ {
vector<double> result(size(), 0.0); std::vector<double> result(size(), 0.0);
for (unsigned i = 0; i < size(); ++i) for (unsigned i = 0; i < size(); ++i)
{ {
@ -159,7 +159,7 @@ class eoDominanceMap : public eoUF<const eoPop<EoType>&, void>, public std::vect
private : private :
vector<typename EoType::Fitness> fitness; std::vector<typename EoType::Fitness> fitness;
}; };
#endif #endif

10
eo/src/eoEasyEA.h
View file

@ -188,16 +188,16 @@ template<class EOT> class eoEasyEA: public eoAlgo<EOT>
replace(_pop, offspring); // after replace, the new pop. is in _pop replace(_pop, offspring); // after replace, the new pop. is in _pop
if (pSize > _pop.size()) if (pSize > _pop.size())
throw runtime_error("Population shrinking!"); throw std::runtime_error("Population shrinking!");
else if (pSize < _pop.size()) else if (pSize < _pop.size())
throw runtime_error("Population growing!"); throw std::runtime_error("Population growing!");
} }
catch (exception& e) catch (std::exception& e)
{ {
string s = e.what(); std::string s = e.what();
s.append( " in eoEasyEA"); s.append( " in eoEasyEA");
throw runtime_error( s ); throw std::runtime_error( s );
} }
} while ( continuator( _pop ) ); } while ( continuator( _pop ) );
} }

4
eo/src/eoEvalContinue.h
View file

@ -39,7 +39,7 @@ public:
/// Ctor /// Ctor
eoEvalContinue( eoEvalFuncCounter<EOT> & _eval, unsigned long _totalEval) eoEvalContinue( eoEvalFuncCounter<EOT> & _eval, unsigned long _totalEval)
: eval(_eval), repTotalEvaluations( _totalEval ) { : eval(_eval), repTotalEvaluations( _totalEval ) {
cout << "Ctor de eoEvalFuncCounter avec total = " << repTotalEvaluations << endl; std::cout << "Ctor de eoEvalFuncCounter avec total = " << repTotalEvaluations << std::endl;
}; };
/** Returns false when a certain number of evaluations has been done /** Returns false when a certain number of evaluations has been done
@ -47,7 +47,7 @@ public:
virtual bool operator() ( const eoPop<EOT>& _vEO ) { virtual bool operator() ( const eoPop<EOT>& _vEO ) {
if (eval.value() >= repTotalEvaluations) if (eval.value() >= repTotalEvaluations)
{ {
cout << "STOP in eoEvalContinue: Reached maximum number of evaluations [" << repTotalEvaluations << "]\n"; std::cout << "STOP in eoEvalContinue: Reached maximum number of evaluations [" << repTotalEvaluations << "]\n";
return false; return false;
} }
return true; return true;

8
eo/src/eoFactory.h
View file

@ -52,16 +52,16 @@ public:
virtual ~eoFactory() {} virtual ~eoFactory() {}
//@} //@}
/** Another factory methods: creates an object from an istream, reading from /** Another factory methods: creates an object from an std::istream, reading from
it whatever is needed to create the object. Usually, the format for the istream will be\\ it whatever is needed to create the object. Usually, the format for the std::istream will be\\
objectType parameter1 parameter2 ... parametern\\ objectType parameter1 parameter2 ... parametern\\
*/ */
virtual EOClass* make(istream& _is) = 0; virtual EOClass* make(std::istream& _is) = 0;
///@name eoObject methods ///@name eoObject methods
//@{ //@{
/** Return the class id */ /** Return the class id */
virtual string className() const { return "eoFactory"; } virtual std::string className() const { return "eoFactory"; }
/** Read and print are left without implementation */ /** Read and print are left without implementation */
//@} //@}

2
eo/src/eoFitContinue.h
View file

@ -50,7 +50,7 @@ public:
FitnessType bestCurrentFitness = _pop.nth_element_fitness(0); FitnessType bestCurrentFitness = _pop.nth_element_fitness(0);
if (bestCurrentFitness >= maximum) if (bestCurrentFitness >= maximum)
{ {
cout << "STOP in eoFitContinue: Best fitness has reached " << std::cout << "STOP in eoFitContinue: Best fitness has reached " <<
bestCurrentFitness << "\n"; bestCurrentFitness << "\n";
return false; return false;
} }

4
eo/src/eoG3Replacement.h
View file

@ -70,8 +70,8 @@ public:
// minimla check: // minimla check:
if (_offspring.size() != toKeep) if (_offspring.size() != toKeep)
{ {
cerr << "Les tailles " << _offspring.size() << " " << toKeep << endl; std::cerr << "Les tailles " << _offspring.size() << " " << toKeep << std::endl;
throw runtime_error("eoG3Replacement: wrong number of remaining offspring"); throw std::runtime_error("eoG3Replacement: wrong number of remaining offspring");
} }
// and put back into _parents // and put back into _parents
plus(_offspring, _parents); plus(_offspring, _parents);

4
eo/src/eoGenContinue.h
View file

@ -51,10 +51,10 @@ public:
* reached */ * reached */
virtual bool operator() ( const eoPop<EOT>& _vEO ) { virtual bool operator() ( const eoPop<EOT>& _vEO ) {
thisGeneration++; thisGeneration++;
// cout << " [" << thisGeneration << "] "; // std::cout << " [" << thisGeneration << "] ";
if (thisGeneration >= repTotalGenerations) if (thisGeneration >= repTotalGenerations)
{ {
cout << "STOP in eoGenContinue: Reached maximum number of generations [" << thisGeneration << "/" << repTotalGenerations << "]\n"; std::cout << "STOP in eoGenContinue: Reached maximum number of generations [" << thisGeneration << "/" << repTotalGenerations << "]\n";
return false; return false;
} }
return true; return true;

10
eo/src/eoGenOp.h
View file

@ -64,7 +64,7 @@ class eoGenOp : public eoOp<EOT>, public eoUF<eoPopulator<EOT> &, void>
*/ */
virtual unsigned max_production(void) = 0; virtual unsigned max_production(void) = 0;
virtual string className() const = 0; virtual std::string className() const = 0;
void operator()(eoPopulator<EOT>& _pop) void operator()(eoPopulator<EOT>& _pop)
{ {
_pop.reserve(max_production()); _pop.reserve(max_production());
@ -94,7 +94,7 @@ class eoMonGenOp : public eoGenOp<EOT>
(*_it).invalidate(); // look how simple (*_it).invalidate(); // look how simple
} }
virtual string className() const {return op.className();} virtual std::string className() const {return op.className();}
private : private :
eoMonOp<EOT>& op; eoMonOp<EOT>& op;
}; };
@ -121,7 +121,7 @@ class eoBinGenOp : public eoGenOp<EOT>
if (op(a, b)) if (op(a, b))
a.invalidate(); a.invalidate();
} }
virtual string className() const {return op.className();} virtual std::string className() const {return op.className();}
private : private :
eoBinOp<EOT>& op; eoBinOp<EOT>& op;
@ -142,7 +142,7 @@ class eoSelBinGenOp : public eoGenOp<EOT>
if (op(*_pop, sel(_pop.source()))) if (op(*_pop, sel(_pop.source())))
(*_pop).invalidate(); (*_pop).invalidate();
} }
virtual string className() const {return op.className();} virtual std::string className() const {return op.className();}
private : private :
eoBinOp<EOT>& op; eoBinOp<EOT>& op;
@ -173,7 +173,7 @@ class eoQuadGenOp : public eoGenOp<EOT>
} }
} }
virtual string className() const {return op.className();} virtual std::string className() const {return op.className();}
private : private :
eoQuadOp<EOT>& op; eoQuadOp<EOT>& op;

2
eo/src/eoGeneralBreeder.h
View file

@ -94,7 +94,7 @@ class eoGeneralBreeder: public eoBreed<EOT>
} }
/// The class name. /// The class name.
virtual string className() const { return "eoGeneralBreeder"; } virtual std::string className() const { return "eoGeneralBreeder"; }
private: private:
eoSelectOne<EOT>& select; eoSelectOne<EOT>& select;

8
eo/src/eoInit.h
View file

@ -47,7 +47,7 @@ class eoInit : public eoUF<EOT&, void>
public: public:
// virtual void operator()(EOT& chrom) // virtual void operator()(EOT& chrom)
// { // {
// throw runtime_error("In the eoInit base class"); // just in case // throw std::runtime_error("In the eoInit base class"); // just in case
// } // }
}; };
@ -115,7 +115,7 @@ typedef typename EOT::AtomType AtomType;
// generator(_generator) // generator(_generator)
// { // {
// if (_minSize >= _maxSize) // if (_minSize >= _maxSize)
// throw logic_error("eoInitVariableLength: minSize larger or equal to maxSize"); // throw std::logic_error("eoInitVariableLength: minSize larger or equal to maxSize");
// } // }
/** Ctor from an eoInit */ /** Ctor from an eoInit */
@ -123,14 +123,14 @@ typedef typename EOT::AtomType AtomType;
: offset(_minSize), extent(_maxSize - _minSize), init(_init) : offset(_minSize), extent(_maxSize - _minSize), init(_init)
{ {
if (_minSize >= _maxSize) if (_minSize >= _maxSize)
throw logic_error("eoInitVariableLength: minSize larger or equal to maxSize"); throw std::logic_error("eoInitVariableLength: minSize larger or equal to maxSize");
} }
virtual void operator()(EOT& _chrom) virtual void operator()(EOT& _chrom)
{ {
_chrom.resize(offset + rng.random(extent)); _chrom.resize(offset + rng.random(extent));
typename vector<AtomType>::iterator it; typename std::vector<AtomType>::iterator it;
for (it=_chrom.begin(); it<_chrom.end(); it++) for (it=_chrom.begin(); it<_chrom.end(); it++)
init(*it); init(*it);
_chrom.invalidate(); _chrom.invalidate();

2
eo/src/eoLinearFitScaling.h
View file

@ -78,7 +78,7 @@ public:
for (i=0; i<pSize; i++) // truncate to 0 for (i=0; i<pSize; i++) // truncate to 0
{ {
value()[i] = max(alpha*_pop[i].fitness()+beta, 0.0); value()[i] = std::max(alpha*_pop[i].fitness()+beta, 0.0);
} }
} }

4
eo/src/eoMGGReplacement.h
View file

@ -58,7 +58,7 @@ public:
{ {
if (tSize < 2) if (tSize < 2)
{ {
cout << "Warning, Size for eoDetTournamentTruncateSplit adjusted to 2\n"; std::cout << "Warning, Size for eoDetTournamentTruncateSplit adjusted to 2\n";
tSize = 2; tSize = 2;
} }
} }
@ -70,7 +70,7 @@ public:
unsigned toKeep = temp.size(); // how many to keep from merged populations unsigned toKeep = temp.size(); // how many to keep from merged populations
// minimal check // minimal check
if (toKeep < 2) if (toKeep < 2)
throw runtime_error("Not enough parents killed in eoMGGReplacement"); throw std::runtime_error("Not enough parents killed in eoMGGReplacement");
// select best offspring // select best offspring
eoPop<EOT>::iterator it = _offspring.it_best_element(); eoPop<EOT>::iterator it = _offspring.it_best_element();

4
eo/src/eoMerge.h
View file

@ -70,7 +70,7 @@ public :
throw std::logic_error("Negative number of offspring in eoElitism!"); throw std::logic_error("Negative number of offspring in eoElitism!");
combien = (unsigned int)_rate; combien = (unsigned int)_rate;
if (combien != _rate) if (combien != _rate)
cout << "Warning: Number of guys to merge in eoElitism was rounded"; std::cout << "Warning: Number of guys to merge in eoElitism was rounded";
} }
} }
@ -87,7 +87,7 @@ public :
if (combienLocal > _pop.size()) if (combienLocal > _pop.size())
throw std::logic_error("Elite larger than population"); throw std::logic_error("Elite larger than population");
vector<const EOT*> result; std::vector<const EOT*> result;
_pop.nth_element(combienLocal, result); _pop.nth_element(combienLocal, result);
for (size_t i = 0; i < result.size(); ++i) for (size_t i = 0; i < result.size(); ++i)

60
eo/src/eoNDSorting.h
View file

@ -34,7 +34,7 @@
#include <cassert> #include <cassert>
/** /**
Non dominated sorting, it *is a* vector of doubles, the integer part is the rank (to which front it belongs), Non dominated sorting, it *is a* std::vector of doubles, the integer part is the rank (to which front it belongs),
the fractional part the niching penalty or distance penalty or whatever penalty you want to squeeze into the fractional part the niching penalty or distance penalty or whatever penalty you want to squeeze into
the bits. the bits.
*/ */
@ -47,10 +47,10 @@ class eoNDSorting : public eoPerf2WorthCached<EOT, double>
{} {}
/** Pure virtual function that calculates the 'distance' for each element in the current front /** Pure virtual function that calculates the 'distance' for each element in the current front
Implement to create your own nondominated sorting algorithm. The size of the returned vector Implement to create your own nondominated sorting algorithm. The size of the returned std::vector
should be equal to the size of the current_front. should be equal to the size of the current_front.
*/ */
virtual vector<double> niche_penalty(const vector<unsigned>& current_front, const eoPop<EOT>& _pop) = 0; virtual std::vector<double> niche_penalty(const std::vector<unsigned>& current_front, const eoPop<EOT>& _pop) = 0;
void calculate_worths(const eoPop<EOT>& _pop) void calculate_worths(const eoPop<EOT>& _pop)
{ {
@ -92,7 +92,7 @@ private :
void one_objective(const eoPop<EOT>& _pop) void one_objective(const eoPop<EOT>& _pop)
{ {
unsigned i; unsigned i;
vector<DummyEO> tmp_pop; std::vector<DummyEO> tmp_pop;
tmp_pop.resize(_pop.size()); tmp_pop.resize(_pop.size());
// copy pop to dummy population (only need the fitnesses) // copy pop to dummy population (only need the fitnesses)
@ -102,10 +102,6 @@ private :
tmp_pop[i].index = i; tmp_pop[i].index = i;
} }
// sort it in ascending
sort(tmp_pop.begin(), tmp_pop.end(), greater<DummyEO>() );
for (i = 0; i < _pop.size(); ++i) for (i = 0; i < _pop.size(); ++i)
{ {
value()[tmp_pop[i].index] = _pop.size() - i; // set rank value()[tmp_pop[i].index] = _pop.size() - i; // set rank
@ -138,7 +134,7 @@ private :
typedef typename EOT::Fitness::fitness_traits traits; typedef typename EOT::Fitness::fitness_traits traits;
assert(traits::nObjectives() == 2); assert(traits::nObjectives() == 2);
vector<unsigned> sort1(_pop.size()); // index into population sorted on first objective std::vector<unsigned> sort1(_pop.size()); // index into population sorted on first objective
for (i = 0; i < _pop.size(); ++i) for (i = 0; i < _pop.size(); ++i)
{ {
@ -160,10 +156,10 @@ private :
max1 = max1 + 1.0; // add a bit to it so that it is a real upperbound max1 = max1 + 1.0; // add a bit to it so that it is a real upperbound
unsigned prev_front = 0; unsigned prev_front = 0;
vector<double> d; std::vector<double> d;
d.resize(_pop.size(), max1); // initialize with the value max1 everywhere d.resize(_pop.size(), max1); // initialize with the value max1 everywhere
vector<vector<unsigned> > fronts(_pop.size()); // to store indices into the front std::vector<std::vector<unsigned> > fronts(_pop.size()); // to store indices into the front
for (i = 0; i < _pop.size(); ++i) for (i = 0; i < _pop.size(); ++i)
{ {
@ -191,7 +187,7 @@ private :
value2 = max1 - value2; value2 = max1 - value2;
// perform binary search using std::upper_bound, a log n operation for each member // perform binary search using std::upper_bound, a log n operation for each member
vector<double>::iterator it = std::vector<double>::iterator it =
std::upper_bound(d.begin(), d.begin() + last_front, value2); std::upper_bound(d.begin(), d.begin() + last_front, value2);
unsigned front = unsigned(it - d.begin()); unsigned front = unsigned(it - d.begin());
@ -212,15 +208,15 @@ private :
if (fronts[i].size() == 0) continue; if (fronts[i].size() == 0) continue;
// Now we have the indices to the current front in current_front, do the niching // Now we have the indices to the current front in current_front, do the niching
vector<double> niche_count = niche_penalty(fronts[i], _pop); std::vector<double> niche_count = niche_penalty(fronts[i], _pop);
// Check whether the derived class was nice // Check whether the derived class was nice
if (niche_count.size() != fronts[i].size()) if (niche_count.size() != fronts[i].size())
{ {
throw logic_error("eoNDSorting: niche and front should have the same size"); throw std::logic_error("eoNDSorting: niche and front should have the same size");
} }
double max_niche = *max_element(niche_count.begin(), niche_count.end()); double max_niche = *std::max_element(niche_count.begin(), niche_count.end());
for (unsigned j = 0; j < fronts[i].size(); ++j) for (unsigned j = 0; j < fronts[i].size(); ++j)
{ {
@ -270,8 +266,8 @@ private :
typedef typename EOT::Fitness::fitness_traits traits; typedef typename EOT::Fitness::fitness_traits traits;
vector<vector<unsigned> > S(_pop.size()); // which individuals does guy i dominate std::vector<std::vector<unsigned> > S(_pop.size()); // which individuals does guy i dominate
vector<unsigned> n(_pop.size(), 0); // how many individuals dominate guy i std::vector<unsigned> n(_pop.size(), 0); // how many individuals dominate guy i
unsigned j; unsigned j;
for (i = 0; i < _pop.size(); ++i) for (i = 0; i < _pop.size(); ++i)
@ -280,12 +276,12 @@ private :
{ {
if (_pop[i].fitness().dominates(_pop[j].fitness())) if (_pop[i].fitness().dominates(_pop[j].fitness()))
{ // i dominates j { // i dominates j
S[i].push_back(j); // add j to i's domination list S[i].push_back(j); // add j to i's domination std::list
//n[j]++; // as i dominates j //n[j]++; // as i dominates j
} }
else if (_pop[j].fitness().dominates(_pop[i].fitness())) else if (_pop[j].fitness().dominates(_pop[i].fitness()))
{ // j dominates i, increment count for i, add i to the domination list of j { // j dominates i, increment count for i, add i to the domination std::list of j
n[i]++; n[i]++;
//S[j].push_back(i); //S[j].push_back(i);
@ -293,7 +289,7 @@ private :
} }
} }
vector<unsigned> current_front; std::vector<unsigned> current_front;
current_front.reserve(_pop.size()); current_front.reserve(_pop.size());
// get the first front out // get the first front out
@ -305,22 +301,22 @@ private :
} }
} }
vector<unsigned> next_front; std::vector<unsigned> next_front;
next_front.reserve(_pop.size()); next_front.reserve(_pop.size());
unsigned front_index = 0; // which front are we processing unsigned front_index = 0; // which front are we processing
while (!current_front.empty()) while (!current_front.empty())
{ {
// Now we have the indices to the current front in current_front, do the niching // Now we have the indices to the current front in current_front, do the niching
vector<double> niche_count = niche_penalty(current_front, _pop); std::vector<double> niche_count = niche_penalty(current_front, _pop);
// Check whether the derived class was nice // Check whether the derived class was nice
if (niche_count.size() != current_front.size()) if (niche_count.size() != current_front.size())
{ {
throw logic_error("eoNDSorting: niche and front should have the same size"); throw std::logic_error("eoNDSorting: niche and front should have the same size");
} }
double max_niche = *max_element(niche_count.begin(), niche_count.end()); double max_niche = *std::max_element(niche_count.begin(), niche_count.end());
for (i = 0; i < current_front.size(); ++i) for (i = 0; i < current_front.size(); ++i)
{ {
@ -377,9 +373,9 @@ class eoNDSorting_I : public eoNDSorting<EOT>
public : public :
eoNDSorting_I(double _nicheSize) : eoNDSorting<EOT>(), nicheSize(_nicheSize) {} eoNDSorting_I(double _nicheSize) : eoNDSorting<EOT>(), nicheSize(_nicheSize) {}
vector<double> niche_penalty(const vector<unsigned>& current_front, const eoPop<EOT>& _pop) std::vector<double> niche_penalty(const std::vector<unsigned>& current_front, const eoPop<EOT>& _pop)
{ {
vector<double> niche_count(current_front.size(), 0.); std::vector<double> niche_count(current_front.size(), 0.);
for (unsigned i = 0; i < current_front.size(); ++i) for (unsigned i = 0; i < current_front.size(); ++i)
{ // calculate whether the other points lie within the nice { // calculate whether the other points lie within the nice
@ -415,7 +411,7 @@ public :
Adapted from Deb, Agrawal, Pratab and Meyarivan: A Fast Elitist Non-Dominant Sorting Genetic Algorithm for MultiObjective Optimization: NSGA-II Adapted from Deb, Agrawal, Pratab and Meyarivan: A Fast Elitist Non-Dominant Sorting Genetic Algorithm for MultiObjective Optimization: NSGA-II
KanGAL Report No. 200001 KanGAL Report No. 200001
Note that this class does not do the sorting per se, but the sorting of it worth_vector will give the right order Note that this class does not do the sorting per se, but the sorting of it worth_std::vector will give the right order
The crowding distance is calculated as the sum of the distances to the nearest neighbours. As we need to return the The crowding distance is calculated as the sum of the distances to the nearest neighbours. As we need to return the
penalty value, we have to invert that and invert it again in the base class, but such is life, sigh penalty value, we have to invert that and invert it again in the base class, but such is life, sigh
@ -437,11 +433,11 @@ class eoNDSorting_II : public eoNDSorting<EOT>
}; };
/// _cf points into the elements that consist of the current front /// _cf points into the elements that consist of the current front
vector<double> niche_penalty(const vector<unsigned>& _cf, const eoPop<EOT>& _pop) std::vector<double> niche_penalty(const std::vector<unsigned>& _cf, const eoPop<EOT>& _pop)
{ {
typedef typename EOT::Fitness::fitness_traits traits; typedef typename EOT::Fitness::fitness_traits traits;
unsigned i; unsigned i;
vector<double> niche_count(_cf.size(), 0.); std::vector<double> niche_count(_cf.size(), 0.);
unsigned nObjectives = traits::nObjectives(); //_pop[_cf[0]].fitness().size(); unsigned nObjectives = traits::nObjectives(); //_pop[_cf[0]].fitness().size();
@ -449,7 +445,7 @@ class eoNDSorting_II : public eoNDSorting<EOT>
for (unsigned o = 0; o < nObjectives; ++o) for (unsigned o = 0; o < nObjectives; ++o)
{ {
vector<pair<double, unsigned> > performance(_cf.size()); std::vector<std::pair<double, unsigned> > performance(_cf.size());
for (i =0; i < _cf.size(); ++i) for (i =0; i < _cf.size(); ++i)
{ {
performance[i].first = _pop[_cf[i]].fitness()[o]; performance[i].first = _pop[_cf[i]].fitness()[o];
@ -458,14 +454,14 @@ class eoNDSorting_II : public eoNDSorting<EOT>
sort(performance.begin(), performance.end(), compare_nodes()); // a lambda operator would've been nice here sort(performance.begin(), performance.end(), compare_nodes()); // a lambda operator would've been nice here
vector<double> nc(niche_count.size(), 0.0); std::vector<double> nc(niche_count.size(), 0.0);
for (i = 1; i < _cf.size()-1; ++i) for (i = 1; i < _cf.size()-1; ++i)
{ // and yet another level of indirection { // and yet another level of indirection
nc[performance[i].second] = performance[i+1].first - performance[i-1].first; nc[performance[i].second] = performance[i+1].first - performance[i-1].first;
} }
double max_dist = *max_element(nc.begin(), nc.end()); double max_dist = *std::max_element(nc.begin(), nc.end());
// set boundary at max_dist + 1 (so it will get chosen over all the others // set boundary at max_dist + 1 (so it will get chosen over all the others
nc[performance[0].second] = max_dist + 1; nc[performance[0].second] = max_dist + 1;

8
eo/src/eoObject.h
View file

@ -28,13 +28,11 @@
//----------------------------------------------------------------------------- //-----------------------------------------------------------------------------
#include <utils/eoData.h> // For limits definition #include <utils/eoData.h> // For limits definition
#include <iostream> // istream, ostream #include <iostream> // std::istream, std::ostream
#include <string> // string #include <string> // std::string
#include <utils/compatibility.h> #include <utils/compatibility.h>
using namespace std;
//----------------------------------------------------------------------------- //-----------------------------------------------------------------------------
// eoObject // eoObject
//----------------------------------------------------------------------------- //-----------------------------------------------------------------------------
@ -69,7 +67,7 @@ class eoObject
their own. Having it pure will force the implementor to provide a their own. Having it pure will force the implementor to provide a
name. name.
*/ */
virtual string className() const = 0; virtual std::string className() const = 0;
}; };

4
eo/src/eoOneToOneBreeder.h
View file

@ -96,7 +96,7 @@ class eoOneToOneBreeder: public eoBreed<EOT>
// check: only one offspring? // check: only one offspring?
unsigned posEnd = popit.tellp(); unsigned posEnd = popit.tellp();
if (posEnd != pos) if (posEnd != pos)
throw runtime_error("Operator can only generate a SINGLE offspring in eoOneToOneBreeder"); throw std::runtime_error("Operator can only generate a SINGLE offspring in eoOneToOneBreeder");
// do the tournament between parent and offspring // do the tournament between parent and offspring
eval(leOffspring); // first need to evaluate the offspring eval(leOffspring); // first need to evaluate the offspring
@ -109,7 +109,7 @@ class eoOneToOneBreeder: public eoBreed<EOT>
} }
/// The class name. /// The class name.
virtual string className() const { return "eoOneToOneBreeder"; } virtual std::string className() const { return "eoOneToOneBreeder"; }
private: private:
eoGenOp<EOT>& op; eoGenOp<EOT>& op;

14
eo/src/eoOp.h
View file

@ -18,7 +18,7 @@
Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
Contact: todos@geneura.ugr.es, http://geneura.ugr.es Contact: todos@geneura.ugr.es, http://geneura.ugr.es
CVS Info: $Date: 2001-03-21 12:10:13 $ $Header: /home/nojhan/dev/eodev/eodev_cvs/eo/src/eoOp.h,v 1.27 2001-03-21 12:10:13 jmerelo Exp $ $Author: jmerelo $ CVS Info: $Date: 2003-02-27 19:25:56 $ $Header: /home/nojhan/dev/eodev/eodev_cvs/eo/src/eoOp.h,v 1.28 2003-02-27 19:25:56 okoenig Exp $ $Author: okoenig $
*/ */
//----------------------------------------------------------------------------- //-----------------------------------------------------------------------------
@ -58,9 +58,9 @@ how to build them from a description in a file.
/** Abstract data types for EO operators. /** Abstract data types for EO operators.
Genetic operators act on chromosomes, changing them. Genetic operators act on chromosomes, changing them.
The type to use them on is problem specific. If your genotype The type to use them on is problem specific. If your genotype
is a vector<bool>, there are operators that work specifically is a std::vector<bool>, there are operators that work specifically
on vector<bool>, but you might also find that generic operators on std::vector<bool>, but you might also find that generic operators
working on vector<T> are what you need. working on std::vector<T> are what you need.
*/ */
template<class EOType> template<class EOType>
@ -103,7 +103,7 @@ public:
/// Ctor /// Ctor
eoMonOp() eoMonOp()
: eoOp<EOType>( eoOp<EOType>::unary ) {}; : eoOp<EOType>( eoOp<EOType>::unary ) {};
virtual string className() const {return "eoMonOp";}; virtual std::string className() const {return "eoMonOp";};
}; };
@ -119,7 +119,7 @@ public:
/// Ctor /// Ctor
eoBinOp() eoBinOp()
:eoOp<EOType>( eoOp<EOType>::binary ) {}; :eoOp<EOType>( eoOp<EOType>::binary ) {};
virtual string className() const {return "eoBinOp";}; virtual std::string className() const {return "eoBinOp";};
}; };
/** Quad genetic operator: subclasses eoOp, and defines basically the /** Quad genetic operator: subclasses eoOp, and defines basically the
@ -133,7 +133,7 @@ public:
/// Ctor /// Ctor
eoQuadOp() eoQuadOp()
:eoOp<EOType>( eoOp<EOType>::quadratic ) {}; :eoOp<EOType>( eoOp<EOType>::quadratic ) {};
virtual string className() const {return "eoQuadOp";}; virtual std::string className() const {return "eoQuadOp";};
}; };
/** Turning an eoQuadOp into an eoBinOp: simply don't touch the second arg! /** Turning an eoQuadOp into an eoBinOp: simply don't touch the second arg!

20
eo/src/eoOpContainer.h
View file

@ -64,15 +64,15 @@ class eoOpContainer : public eoGenOp<EOT>
{ {
ops.push_back(&wrap_op<EOT>(_op, store)); ops.push_back(&wrap_op<EOT>(_op, store));
rates.push_back(_rate); rates.push_back(_rate);
max_to_produce = max(max_to_produce,ops.back()->max_production()); max_to_produce = std::max(max_to_produce,ops.back()->max_production());
} }
virtual string className() const = 0; virtual std::string className() const = 0;
protected : protected :
vector<double> rates; std::vector<double> rates;
vector<eoGenOp<EOT>*> ops; std::vector<eoGenOp<EOT>*> ops;
private : private :
eoFunctorStore store; eoFunctorStore store;
@ -105,13 +105,13 @@ class eoSequentialOp : public eoOpContainer<EOT>
{ {
// try // try
// { // {
// apply it to all the guys in the todo list // apply it to all the guys in the todo std::list
(*ops[i])(_pop); (*ops[i])(_pop);
// } // }
// check for out of individuals and do nothing with that... // check for out of individuals and do nothing with that...
// catch(eoPopulator<EOT>::OutOfIndividuals&) // catch(eoPopulator<EOT>::OutOfIndividuals&)
// { // {
// cout << "Warning: not enough individuals to handle\n"; // std::cout << "Warning: not enough individuals to handle\n";
// return ; // return ;
// } // }
} }
@ -122,12 +122,12 @@ class eoSequentialOp : public eoOpContainer<EOT>
while (!_pop.exhausted()); while (!_pop.exhausted());
} }
} }
virtual string className() const {return "SequentialOp";} virtual std::string className() const {return "SequentialOp";}
private : private :
vector<size_t> to_apply; std::vector<size_t> to_apply;
vector<size_t> production; std::vector<size_t> production;
}; };
@ -149,7 +149,7 @@ class eoProportionalOp : public eoOpContainer<EOT>
catch( typename eoPopulator<EOT>::OutOfIndividuals&) catch( typename eoPopulator<EOT>::OutOfIndividuals&)
{} {}
} }
virtual string className() const {return "ProportionalOp";} virtual std::string className() const {return "ProportionalOp";}
}; };

14
eo/src/eoOpSelMason.h
View file

@ -39,7 +39,7 @@ template<class eoClass>
class eoOpSelMason: public eoFactory<eoOpSelector<eoClass> > { class eoOpSelMason: public eoFactory<eoOpSelector<eoClass> > {
public: public:
typedef vector<eoOp<eoClass>* > vOpP; typedef std::vector<eoOp<eoClass>* > vOpP;
typedef map<eoOpSelector<eoClass>*, vOpP > MEV; typedef map<eoOpSelector<eoClass>*, vOpP > MEV;
/// @name ctors and dtors /// @name ctors and dtors
@ -51,7 +51,7 @@ public:
virtual ~eoOpSelMason() {}; virtual ~eoOpSelMason() {};
//@} //@}
/** Factory methods: creates an object from an istream, reading from /** Factory methods: creates an object from an std::istream, reading from
it whatever is needed to create the object. The format is it whatever is needed to create the object. The format is
opSelClassName\\ opSelClassName\\
rate 1 operator1\\ rate 1 operator1\\
@ -62,9 +62,9 @@ public:
since the built object can´t do it itself. The objects built must be destroyed since the built object can´t do it itself. The objects built must be destroyed
from outside, using the #destroy# method from outside, using the #destroy# method
*/ */
virtual eoOpSelector<eoClass>* make(istream& _is) { virtual eoOpSelector<eoClass>* make(std::istream& _is) {
string opSelName; std::string opSelName;
_is >> opSelName; _is >> opSelName;
eoOpSelector<eoClass>* opSelectorP; eoOpSelector<eoClass>* opSelectorP;
// Build the operator selector // Build the operator selector
@ -72,7 +72,7 @@ public:
opSelectorP = new eoProportionalOpSel<eoClass>(); opSelectorP = new eoProportionalOpSel<eoClass>();
} }
// Temp vector for storing pointers // Temp std::vector for storing pointers
vOpP tmpPVec; vOpP tmpPVec;
// read operator rate and name // read operator rate and name
while ( _is ) { while ( _is ) {
@ -96,12 +96,12 @@ public:
///@name eoObject methods ///@name eoObject methods
//@{ //@{
/** Return the class id */ /** Return the class id */
virtual string className() const { return "eoOpSelMason"; } virtual std::string className() const { return "eoOpSelMason"; }
//@} //@}
private: private:
map<eoOpSelector<eoClass>*,vector<eoOp<eoClass>* > > allocMap; map<eoOpSelector<eoClass>*,std::vector<eoOp<eoClass>* > > allocMap;
eoOpFactory<eoClass>& operatorFactory; eoOpFactory<eoClass>& operatorFactory;
}; };

8
eo/src/eoParetoConstraintFitness.h
View file

@ -70,25 +70,25 @@ public :
eoParetoOneConstraintFitness(void) : std::vector<double>(FitnessTraits::nObjectives(),0.0) {} eoParetoOneConstraintFitness(void) : std::vector<double>(FitnessTraits::nObjectives(),0.0) {}
// Ctr from a vector<double> (size nObjectives+1) // Ctr from a std::vector<double> (size nObjectives+1)
eoParetoOneConstraintFitness(std::vector<double> & _v) : eoParetoOneConstraintFitness(std::vector<double> & _v) :
std::vector<double>(_v) std::vector<double>(_v)
{ {
#ifndef NDEBUG #ifndef NDEBUG
if (_v.size() != fitness_traits::nObjectives()+1) if (_v.size() != fitness_traits::nObjectives()+1)
throw runtime_error("Size error in Ctor of eoParetoOneConstraintFitness from vector"); throw std::runtime_error("Size error in Ctor of eoParetoOneConstraintFitness from std::vector");
#endif #endif
constraintValue = _v[fitness_traits::nObjectives()]; constraintValue = _v[fitness_traits::nObjectives()];
resize(fitness_traits::nObjectives()); resize(fitness_traits::nObjectives());
} }
// Ctr from a vector<double> and a value // Ctr from a std::vector<double> and a value
eoParetoOneConstraintFitness(std::vector<double> & _v, double _c) : eoParetoOneConstraintFitness(std::vector<double> & _v, double _c) :
std::vector<double>(_v), constraintValue(_c) std::vector<double>(_v), constraintValue(_c)
{ {
#ifndef NDEBUG #ifndef NDEBUG
if (_v.size() != fitness_traits::nObjectives()) if (_v.size() != fitness_traits::nObjectives())
throw runtime_error("Size error in Ctor of eoParetoOneConstraintFitness from vector and value"); throw std::runtime_error("Size error in Ctor of eoParetoOneConstraintFitness from std::vector and value");
#endif #endif
} }

2
eo/src/eoParetoFitness.h
View file

@ -113,7 +113,7 @@ public :
eoParetoFitness(void) : std::vector<double>(FitnessTraits::nObjectives(),0.0) {} eoParetoFitness(void) : std::vector<double>(FitnessTraits::nObjectives(),0.0) {}
// Ctr from a vector<double> // Ctr from a std::vector<double>
eoParetoFitness(std::vector<double> & _v) : std::vector<double>(_v) {} eoParetoFitness(std::vector<double> & _v) : std::vector<double>(_v) {}

2
eo/src/eoParetoRanking.h
View file

@ -50,7 +50,7 @@ class eoParetoRanking : public eoPerf2WorthCached<EOT, double>
value() = dominanceMap.sum_dominators(); // get rank: 0 means part of current front value() = dominanceMap.sum_dominators(); // get rank: 0 means part of current front
// calculate maximum // calculate maximum
double maxim = *max_element(value().begin(), value().end()); double maxim = *std::max_element(value().begin(), value().end());
// higher is better, so invert the value // higher is better, so invert the value
for (unsigned i = 0; i < value().size(); ++i) for (unsigned i = 0; i < value().size(); ++i)

16
eo/src/eoPerf2Worth.h
View file

@ -50,7 +50,7 @@ class eoPerf2Worth : public eoUF<const eoPop<EOT>&, void>, public eoValueParam<s
Sort population according to worth, will keep the worths and fitness_cache in sync with the population. Sort population according to worth, will keep the worths and fitness_cache in sync with the population.
*/ */
virtual void sort_pop(eoPop<EOT>& _pop) virtual void sort_pop(eoPop<EOT>& _pop)
{ // start with a vector of indices { // start with a std::vector of indices
std::vector<unsigned> indices(_pop.size()); std::vector<unsigned> indices(_pop.size());
unsigned i; unsigned i;
@ -59,7 +59,7 @@ class eoPerf2Worth : public eoUF<const eoPop<EOT>&, void>, public eoValueParam<s
indices[i] = i; indices[i] = i;
} }
sort(indices.begin(), indices.end(), compare_worth(value())); std::sort(indices.begin(), indices.end(), compare_worth(value()));
eoPop<EOT> tmp_pop; eoPop<EOT> tmp_pop;
tmp_pop.resize(_pop.size()); tmp_pop.resize(_pop.size());
@ -71,8 +71,8 @@ class eoPerf2Worth : public eoUF<const eoPop<EOT>&, void>, public eoValueParam<s
tmp_worths[i] = value()[indices[i]]; tmp_worths[i] = value()[indices[i]];
} }
swap(_pop, tmp_pop); std::swap(_pop, tmp_pop);
swap(value(), tmp_worths); std::swap(value(), tmp_worths);
} }
/** helper class used to sort indices into populations/worths /** helper class used to sort indices into populations/worths
@ -155,7 +155,7 @@ class eoPerf2WorthCached : public eoPerf2Worth<EOT, WorthT>
Sort population according to worth, will keep the worths and fitness_cache in sync with the population. Sort population according to worth, will keep the worths and fitness_cache in sync with the population.
*/ */
virtual void sort_pop(eoPop<EOT>& _pop) virtual void sort_pop(eoPop<EOT>& _pop)
{ // start with a vector of indices { // start with a std::vector of indices
std::vector<unsigned> indices(_pop.size()); std::vector<unsigned> indices(_pop.size());
unsigned i; unsigned i;
@ -183,9 +183,9 @@ class eoPerf2WorthCached : public eoPerf2Worth<EOT, WorthT>
tmp_cache[i] = fitness_cache[indices[i]]; tmp_cache[i] = fitness_cache[indices[i]];
} }
swap(_pop, tmp_pop); std::swap(_pop, tmp_pop);
swap(value(), tmp_worths); std::swap(value(), tmp_worths);
swap(fitness_cache, tmp_cache); std::swap(fitness_cache, tmp_cache);
} }
/** helper class used to sort indices into populations/worths /** helper class used to sort indices into populations/worths

2
eo/src/eoPersistent.cpp
View file

@ -9,7 +9,7 @@
//----------------------------------------------------------------------------- //-----------------------------------------------------------------------------
istream & operator >> ( istream& _is, eoPersistent& _o ) { std::istream & operator >> ( std::istream& _is, eoPersistent& _o ) {
_o.readFrom(_is); _o.readFrom(_is);
return _is; return _is;
}; };

14
eo/src/eoPersistent.h
View file

@ -36,14 +36,12 @@ const unsigned MAXLINELENGTH=1024;
//----------------------------------------------------------------------------- //-----------------------------------------------------------------------------
#include <iostream> // istream, ostream #include <iostream> // std::istream, std::ostream
#include <string> // para string #include <string> // para std::string
//----------------------------------------------------------------------------- //-----------------------------------------------------------------------------
#include "eoPrintable.h" #include "eoPrintable.h"
using namespace std;
//----------------------------------------------------------------------------- //-----------------------------------------------------------------------------
// eoPersistent // eoPersistent
//----------------------------------------------------------------------------- //-----------------------------------------------------------------------------
@ -59,16 +57,16 @@ class eoPersistent: public eoPrintable
/** /**
* Read object. * Read object.
* @param _is A istream. * @param _is A std::istream.
* @throw runtime_exception If a valid object can't be read. * @throw runtime_std::exception If a valid object can't be read.
*/ */
virtual void readFrom(istream& _is) = 0; virtual void readFrom(std::istream& _is) = 0;
}; };
//----------------------------------------------------------------------------- //-----------------------------------------------------------------------------
///Standard input for all objects in the EO hierarchy ///Standard input for all objects in the EO hierarchy
istream & operator >> ( istream& _is, eoPersistent& _o ); std::istream & operator >> ( std::istream& _is, eoPersistent& _o );
#endif #endif

68
eo/src/eoPop.h
View file

@ -36,11 +36,11 @@
#include <eoInit.h> #include <eoInit.h>
#include <utils/rnd_generators.h> // for shuffle method #include <utils/rnd_generators.h> // for shuffle method
/** A vector of EO object, to be used in all algorithms /** A std::vector of EO object, to be used in all algorithms
* (selectors, operators, replacements, ...). * (selectors, operators, replacements, ...).
* *
* We have no idea if a population can be * We have no idea if a population can be
* some other thing that a vector, but if somebody thinks of it, this concrete * some other thing that a std::vector, but if somebody thinks of it, this concrete
* implementation can be moved to "generic" and an abstract Population * implementation can be moved to "generic" and an abstract Population
* interface be provided. * interface be provided.
* *
@ -51,14 +51,14 @@
*/ */
template<class EOT> template<class EOT>
class eoPop: public vector<EOT>, public eoObject, public eoPersistent class eoPop: public std::vector<EOT>, public eoObject, public eoPersistent
{ {
public: public:
typedef typename EOT::Fitness Fitness; typedef typename EOT::Fitness Fitness;
/** Default ctor. Creates empty pop /** Default ctor. Creates empty pop
*/ */
eoPop() : vector<EOT>(), eoObject(), eoPersistent() {}; eoPop() : std::vector<EOT>(), eoObject(), eoPersistent() {};
/** Ctor for the initialization of chromosomes /** Ctor for the initialization of chromosomes
@ -66,7 +66,7 @@ class eoPop: public vector<EOT>, public eoObject, public eoPersistent
@param _chromInit Initialization routine, produces EO's, needs to be an eoInit @param _chromInit Initialization routine, produces EO's, needs to be an eoInit
*/ */
eoPop( unsigned _popSize, eoInit<EOT>& _chromInit ) eoPop( unsigned _popSize, eoInit<EOT>& _chromInit )
:vector<EOT>() :std::vector<EOT>()
{ {
resize(_popSize); resize(_popSize);
for ( unsigned i = 0; i < _popSize; i++ ) for ( unsigned i = 0; i < _popSize; i++ )
@ -75,7 +75,7 @@ class eoPop: public vector<EOT>, public eoObject, public eoPersistent
} }
}; };
/** appends random guys at end of pop. /** appstd::ends random guys at end of pop.
Can be used to initialize it pop is empty Can be used to initialize it pop is empty
@param _popSize total population size @param _popSize total population size
@ -86,7 +86,7 @@ class eoPop: public vector<EOT>, public eoObject, public eoPersistent
unsigned oldSize = size(); unsigned oldSize = size();
if (_newPopSize < oldSize) if (_newPopSize < oldSize)
{ {
throw runtime_error("New size smaller than old size in pop.append"); throw std::runtime_error("New size smaller than old size in pop.append");
return; return;
} }
if (_newPopSize == oldSize) if (_newPopSize == oldSize)
@ -99,11 +99,11 @@ class eoPop: public vector<EOT>, public eoObject, public eoPersistent
}; };
/** Ctor from an istream; reads the population from a stream, /** Ctor from an std::istream; reads the population from a stream,
each element should be in different lines each element should be in different lines
@param _is the stream @param _is the stream
*/ */
eoPop( istream& _is ):vector<EOT>() { eoPop( std::istream& _is ) :std::vector<EOT>() {
readFrom( _is ); readFrom( _is );
} }
@ -125,11 +125,11 @@ class eoPop: public vector<EOT>, public eoObject, public eoPersistent
*/ */
void sort(void) void sort(void)
{ {
std::sort(begin(), end(), greater<EOT>()); std::sort(begin(), end(), std::greater<EOT>());
} }
/** creates a vector<EOT*> pointing to the individuals in descending order */ /** creates a std::vector<EOT*> pointing to the individuals in descending order */
void sort(vector<const EOT*>& result) const void sort(std::vector<const EOT*>& result) const
{ {
result.resize(size()); result.resize(size());
@ -148,8 +148,8 @@ class eoPop: public vector<EOT>, public eoObject, public eoPersistent
std::random_shuffle(begin(), end(), gen); std::random_shuffle(begin(), end(), gen);
} }
/** creates a vector<EOT*> pointing to the individuals in random order */ /** creates a std::vector<EOT*> pointing to the individuals in random order */
void shuffle(vector<const EOT*>& result) const void shuffle(std::vector<const EOT*>& result) const
{ {
result.resize(size()); result.resize(size());
@ -162,28 +162,28 @@ class eoPop: public vector<EOT>, public eoObject, public eoPersistent
/** returns an iterator to the best individual DOES NOT MOVE ANYBODY */ /** returns an iterator to the best individual DOES NOT MOVE ANYBODY */
typename eoPop<EOT>::iterator it_best_element() typename eoPop<EOT>::iterator it_best_element()
{ {
typename eoPop<EOT>::iterator it = max_element(begin(), end()); typename eoPop<EOT>::iterator it = std::max_element(begin(), end());
return it; return it;
} }
/** returns an iterator to the best individual DOES NOT MOVE ANYBODY */ /** returns an iterator to the best individual DOES NOT MOVE ANYBODY */
const EOT & best_element() const const EOT & best_element() const
{ {
typename eoPop<EOT>::const_iterator it = max_element(begin(), end()); typename eoPop<EOT>::const_iterator it = std::max_element(begin(), end());
return (*it); return (*it);
} }
/** returns a const reference to the worse individual DOES NOT MOVE ANYBODY */ /** returns a const reference to the worse individual DOES NOT MOVE ANYBODY */
const EOT & worse_element() const const EOT & worse_element() const
{ {
typename eoPop<EOT>::const_iterator it = min_element(begin(), end()); typename eoPop<EOT>::const_iterator it = std::min_element(begin(), end());
return (*it); return (*it);
} }
/** returns an iterator to the worse individual DOES NOT MOVE ANYBODY */ /** returns an iterator to the worse individual DOES NOT MOVE ANYBODY */
typename eoPop<EOT>::iterator it_worse_element() typename eoPop<EOT>::iterator it_worse_element()
{ {
typename eoPop<EOT>::iterator it = min_element(begin(), end()); typename eoPop<EOT>::iterator it = std::min_element(begin(), end());
return it; return it;
} }
@ -194,7 +194,7 @@ class eoPop: public vector<EOT>, public eoObject, public eoPersistent
typename eoPop<EOT>::iterator nth_element(int nth) typename eoPop<EOT>::iterator nth_element(int nth)
{ {
typename eoPop<EOT>::iterator it = begin() + nth; typename eoPop<EOT>::iterator it = begin() + nth;
std::nth_element(begin(), it, end(), greater<EOT>()); std::nth_element(begin(), it, end(), std::greater<EOT>());
return it; return it;
} }
@ -204,24 +204,24 @@ class eoPop: public vector<EOT>, public eoObject, public eoPersistent
Fitness nth_element_fitness(int which) const Fitness nth_element_fitness(int which) const
{ // probably not the fastest way to do this, but what the heck { // probably not the fastest way to do this, but what the heck
vector<Fitness> fitness(size()); std::vector<Fitness> fitness(size());
std::transform(begin(), end(), fitness.begin(), GetFitness()); std::transform(begin(), end(), fitness.begin(), GetFitness());
typename vector<Fitness>::iterator it = fitness.begin() + which; typename std::vector<Fitness>::iterator it = fitness.begin() + which;
std::nth_element(fitness.begin(), it, fitness.end(), greater<Fitness>()); std::nth_element(fitness.begin(), it, fitness.end(), std::greater<Fitness>());
return *it; return *it;
} }
/** const nth_element function, returns pointers to sorted individuals /** const nth_element function, returns pointers to sorted individuals
* up the the nth * up the the nth
*/ */
void nth_element(int which, vector<const EOT*>& result) const void nth_element(int which, std::vector<const EOT*>& result) const
{ {
result.resize(size()); result.resize(size());
std::transform(begin(), end(), result.begin(), Ref()); std::transform(begin(), end(), result.begin(), Ref());
typename vector<const EOT*>::iterator it = result.begin() + which; typename std::vector<const EOT*>::iterator it = result.begin() + which;
std::nth_element(result.begin(), it, result.end(), Cmp()); std::nth_element(result.begin(), it, result.end(), Cmp());
} }
@ -229,30 +229,30 @@ class eoPop: public vector<EOT>, public eoObject, public eoPersistent
/** does STL swap with other pop */ /** does STL swap with other pop */
void swap(eoPop<EOT>& other) void swap(eoPop<EOT>& other)
{ {
std::swap(static_cast<vector<EOT>& >(*this), static_cast<vector<EOT>& >(other)); std::swap(static_cast<std::vector<EOT>& >(*this), static_cast<std::vector<EOT>& >(other));
} }
/** /**
* Prints sorted pop but does NOT modify it! * Prints sorted pop but does NOT modify it!
* *
* @param _os A ostream. * @param _os A std::ostream.
*/ */
virtual void sortedPrintOn(ostream& _os) const virtual void sortedPrintOn(std::ostream& _os) const
{ {
vector<const EOT*> result; std::vector<const EOT*> result;
sort(result); sort(result);
_os << size() << '\n'; _os << size() << '\n';
for (unsigned i = 0; i < size(); ++i) for (unsigned i = 0; i < size(); ++i)
{ {
_os << *result[i] << endl; _os << *result[i] << std::endl;
} }
} }
/** /**
* Write object. It's called printOn since it prints the object _on_ a stream. * Write object. It's called printOn since it prints the object _on_ a stream.
* @param _os A ostream. * @param _os A std::ostream.
*/ */
virtual void printOn(ostream& _os) const virtual void printOn(std::ostream& _os) const
{ {
_os << size() << '\n'; _os << size() << '\n';
std::copy( begin(), end(), std::ostream_iterator<EOT>( _os, "\n") ); std::copy( begin(), end(), std::ostream_iterator<EOT>( _os, "\n") );
@ -263,9 +263,9 @@ class eoPop: public vector<EOT>, public eoObject, public eoPersistent
/** /**
* Read object. The EOT class must have a ctor from a stream; * Read object. The EOT class must have a ctor from a stream;
in this case, a strstream is used. in this case, a strstream is used.
* @param _is A istream. * @param _is A std::istream.
*/ */
virtual void readFrom(istream& _is) virtual void readFrom(std::istream& _is)
{ {
size_t sz; size_t sz;
_is >> sz; _is >> sz;
@ -280,7 +280,7 @@ class eoPop: public vector<EOT>, public eoObject, public eoPersistent
/** Inherited from eoObject. Returns the class name. /** Inherited from eoObject. Returns the class name.
@see eoObject @see eoObject
*/ */
virtual string className() const {return "eoPop";}; virtual std::string className() const {return "eoPop";};
//@} //@}
virtual void invalidate() virtual void invalidate()

2
eo/src/eoPrintable.cpp
View file

@ -13,7 +13,7 @@
//Implementation of these objects //Implementation of these objects
//----------------------------------------------------------------------------- //-----------------------------------------------------------------------------
ostream & operator << ( ostream& _os, const eoPrintable& _o ) { std::ostream & operator << ( std::ostream& _os, const eoPrintable& _o ) {
_o.printOn(_os); _o.printOn(_os);
return _os; return _os;
}; };

12
eo/src/eoPrintable.h
View file

@ -27,10 +27,8 @@
//----------------------------------------------------------------------------- //-----------------------------------------------------------------------------
#include <iostream> // istream, ostream #include <iostream> // std::istream, std::ostream
#include <string> // para string #include <string> // para std::string
using namespace std;
//----------------------------------------------------------------------------- //-----------------------------------------------------------------------------
// eoPrintable // eoPrintable
@ -50,14 +48,14 @@ class eoPrintable
/** /**
* Write object. It's called printOn since it prints the object on a stream. * Write object. It's called printOn since it prints the object on a stream.
* @param _os A ostream. * @param _os A std::ostream.
*/ */
virtual void printOn(ostream& _os) const = 0; virtual void printOn(std::ostream& _os) const = 0;
}; };
//----------------------------------------------------------------------------- //-----------------------------------------------------------------------------
///Standard output for all objects in the EO hierarchy ///Standard output for all objects in the EO hierarchy
ostream & operator << ( ostream& _os, const eoPrintable& _o ); std::ostream & operator << ( std::ostream& _os, const eoPrintable& _o );
#endif #endif

18
eo/src/eoProportionalCombinedOp.h
View file

@ -65,7 +65,7 @@ public:
rates.push_back(_rate); rates.push_back(_rate);
} }
virtual string className() const { return "eoPropCombinedMonOp"; } virtual std::string className() const { return "eoPropCombinedMonOp"; }
virtual void add(eoMonOp<EOT> & _op, const double _rate, bool _verbose=false) virtual void add(eoMonOp<EOT> & _op, const double _rate, bool _verbose=false)
{ {
@ -73,11 +73,11 @@ public:
rates.push_back(_rate); rates.push_back(_rate);
// compute the relative rates in percent - to warn the user! // compute the relative rates in percent - to warn the user!
if (_verbose) if (_verbose)
printOn(cout); printOn(std::cout);
} }
// outputs the operators and percentages // outputs the operators and percentages
virtual void printOn(ostream & _os) virtual void printOn(std::ostream & _os)
{ {
double total = 0; double total = 0;
unsigned i; unsigned i;
@ -116,7 +116,7 @@ public:
rates.push_back(_rate); rates.push_back(_rate);
} }
virtual string className() const { return "eoPropCombinedBinOp"; } virtual std::string className() const { return "eoPropCombinedBinOp"; }
virtual void add(eoBinOp<EOT> & _op, const double _rate, bool _verbose=false) virtual void add(eoBinOp<EOT> & _op, const double _rate, bool _verbose=false)
{ {
@ -129,9 +129,9 @@ virtual void add(eoBinOp<EOT> & _op, const double _rate, bool _verbose=false)
unsigned i; unsigned i;
for (i=0; i<ops.size(); i++) for (i=0; i<ops.size(); i++)
total += rates[i]; total += rates[i];
cout << "In " << className() << "\n" ; std::cout << "In " << className() << "\n" ;
for (i=0; i<ops.size(); i++) for (i=0; i<ops.size(); i++)
cout << ops[i]->className() << " with rate " << 100*rates[i]/total << " %\n"; std::cout << ops[i]->className() << " with rate " << 100*rates[i]/total << " %\n";
} }
} }
@ -170,7 +170,7 @@ public:
rates.push_back(_rate); rates.push_back(_rate);
} }
virtual string className() const { return "eoPropCombinedQuadOp"; } virtual std::string className() const { return "eoPropCombinedQuadOp"; }
// addition of a true operator // addition of a true operator
virtual void add(eoQuadOp<EOT> & _op, const double _rate, bool _verbose=false) virtual void add(eoQuadOp<EOT> & _op, const double _rate, bool _verbose=false)
@ -179,11 +179,11 @@ virtual void add(eoQuadOp<EOT> & _op, const double _rate, bool _verbose=false)
rates.push_back(_rate); rates.push_back(_rate);
// compute the relative rates in percent - to warn the user! // compute the relative rates in percent - to warn the user!
if (_verbose) if (_verbose)
printOn(cout); printOn(std::cout);
} }
// outputs the operators and percentages // outputs the operators and percentages
virtual void printOn(ostream & _os) virtual void printOn(std::ostream & _os)
{ {
double total = 0; double total = 0;
unsigned i; unsigned i;

2
eo/src/eoProportionalSelect.h
View file

@ -48,7 +48,7 @@ public:
total((pop.size() == 0) ? -1.0 : sum_fitness(pop)) total((pop.size() == 0) ? -1.0 : sum_fitness(pop))
{ {
if (minimizing_fitness<EOT>()) if (minimizing_fitness<EOT>())
throw logic_error("eoProportionalSelect: minimizing fitness"); throw std::logic_error("eoProportionalSelect: minimizing fitness");
} }
void setup(const eoPop<EOT>& _pop) void setup(const eoPop<EOT>& _pop)

12
eo/src/eoRanking.h
View file

@ -32,7 +32,7 @@
/** An instance of eoPerfFromWorth /** An instance of eoPerfFromWorth
* COmputes the ranked fitness: fitnesses range in [m,M] * COmputes the ranked fitness: fitnesses range in [m,M]
* with m=2-pressure/popSize and M=pressure/popSize. * with m=2-pressure/popSize and M=pressure/popSize.
* in between, the progression depends on exponent (linear if 1). * in between, the progression depstd::ends on exponent (linear if 1).
*/ */
template <class EOT> template <class EOT>
class eoRanking : public eoPerf2Worth<EOT> // false: do not cache fitness class eoRanking : public eoPerf2Worth<EOT> // false: do not cache fitness
@ -54,24 +54,24 @@ public:
if (_eo == &(*it)) if (_eo == &(*it))
return it-_pop.begin(); return it-_pop.begin();
} }
throw runtime_error("Not found in eoLinearRanking"); throw std::runtime_error("Not found in eoLinearRanking");
} }
/* COmputes the ranked fitness: fitnesses range in [m,M] /* COmputes the ranked fitness: fitnesses range in [m,M]
with m=2-pressure/popSize and M=pressure/popSize. with m=2-pressure/popSize and M=pressure/popSize.
in between, the progression depends on exponent (linear if 1). in between, the progression depstd::ends on exponent (linear if 1).
*/ */
virtual void operator()(const eoPop<EOT>& _pop) virtual void operator()(const eoPop<EOT>& _pop)
{ {
vector<const EOT *> rank; std::vector<const EOT *> rank;
_pop.sort(rank); _pop.sort(rank);
unsigned pSize =_pop.size(); unsigned pSize =_pop.size();
unsigned int pSizeMinusOne = pSize-1; unsigned int pSizeMinusOne = pSize-1;
if (pSize <= 1) if (pSize <= 1)
throw runtime_error("Cannot do ranking with population of size <= 1"); throw std::runtime_error("Cannot do ranking with population of size <= 1");
// value() refers to the vector of worthes (we're in an eoParamvalue) // value() refers to the std::vector of worthes (we're in an eoParamvalue)
value().resize(pSize); value().resize(pSize);
double beta = (2-pressure)/pSize; double beta = (2-pressure)/pSize;

2
eo/src/eoRankingSelect.h
View file

@ -32,7 +32,7 @@
#include <eoRanking.h> #include <eoRanking.h>
/** eoRankingSelect: select an individual by roulette wheel on its rank /** eoRankingSelect: select an individual by roulette wheel on its rank
* is an eoRouletteWorthSelect, i.e. a selector using a vector of worthes * is an eoRouletteWorthSelect, i.e. a selector using a std::vector of worthes
* rather than the raw fitness (see eoSelectFromWorth.h) * rather than the raw fitness (see eoSelectFromWorth.h)
* uses an internal eoRanking object which is an eoPerf2Worth<EOT, double> * uses an internal eoRanking object which is an eoPerf2Worth<EOT, double>
*/ */

22
eo/src/eoReduce.h
View file

@ -90,15 +90,15 @@ typedef typename EOT::Fitness Fitness;
{ {
if (t_size < 2) if (t_size < 2)
{ {
cout << "Warning: EP tournament size should be >= 2. Adjusted" << endl; std::cout << "Warning: EP tournament size should be >= 2. Adjusted" << std::endl;
t_size = 2; t_size = 2;
} }
} }
/// helper struct for comparing on pairs /// helper struct for comparing on std::pairs
// compares the scores // compares the scores
// uses the fitness if scores are equals ???? // uses the fitness if scores are equals ????
typedef pair<float, typename eoPop<EOT>::iterator> EPpair; typedef std::pair<float, typename eoPop<EOT>::iterator> EPpair;
struct Cmp { struct Cmp {
bool operator()(const EPpair a, const EPpair b) const bool operator()(const EPpair a, const EPpair b) const
{ {
@ -117,7 +117,7 @@ typedef typename EOT::Fitness Fitness;
return; return;
if (presentSize < _newsize) if (presentSize < _newsize)
throw std::logic_error("eoTruncate: Cannot truncate to a larger size!\n"); throw std::logic_error("eoTruncate: Cannot truncate to a larger size!\n");
vector<EPpair> scores(presentSize); std::vector<EPpair> scores(presentSize);
for (unsigned i=0; i<presentSize; i++) for (unsigned i=0; i<presentSize; i++)
{ {
scores[i].second = _newgen.begin()+i; scores[i].second = _newgen.begin()+i;
@ -133,14 +133,14 @@ typedef typename EOT::Fitness Fitness;
} }
// now we have the scores // now we have the scores
typename vector<EPpair>::iterator it = scores.begin() + _newsize; typename std::vector<EPpair>::iterator it = scores.begin() + _newsize;
std::nth_element(scores.begin(), it, scores.end(), Cmp()); std::nth_element(scores.begin(), it, scores.end(), Cmp());
// sort(scores.begin(), scores.end(), Cmp()); // sort(scores.begin(), scores.end(), Cmp());
unsigned j; unsigned j;
// cout << "Les scores apres tri\n"; // std::cout << "Les scores apres tri\n";
// for (j=0; j<scores.size(); j++) // for (j=0; j<scores.size(); j++)
// { // {
// cout << scores[j].first << " " << *scores[j].second << endl; // std::cout << scores[j].first << " " << *scores[j].second << std::endl;
// } // }
eoPop<EOT> tmPop; eoPop<EOT> tmPop;
for (j=0; j<_newsize; j++) for (j=0; j<_newsize; j++)
@ -149,7 +149,7 @@ typedef typename EOT::Fitness Fitness;
} }
_newgen.swap(tmPop); _newgen.swap(tmPop);
// erase does not work, but I'm sure there is a way in STL to mark // erase does not work, but I'm sure there is a way in STL to mark
// and later delete all inside a vector ?????? // and later delete all inside a std::vector ??????
// this would avoid all copies here // this would avoid all copies here
// it = scores.begin() + _newsize; // it = scores.begin() + _newsize;
@ -193,7 +193,7 @@ public:
{ {
if (t_size < 2) if (t_size < 2)
{ {
cout << "Warning, Size for eoDetTournamentTruncate adjusted to 2\n"; std::cout << "Warning, Size for eoDetTournamentTruncate adjusted to 2\n";
t_size = 2; t_size = 2;
} }
} }
@ -241,12 +241,12 @@ public:
{ {
if (t_rate <= 0.5) if (t_rate <= 0.5)
{ {
cout << "Warning, Rate for eoStochTournamentTruncate adjusted to 0.51\n"; std::cout << "Warning, Rate for eoStochTournamentTruncate adjusted to 0.51\n";
t_rate = 0.51; t_rate = 0.51;
} }
if (t_rate > 1) if (t_rate > 1)
{ {
cout << "Warning, Rate for eoStochTournamentTruncate adjusted to 1\n"; std::cout << "Warning, Rate for eoStochTournamentTruncate adjusted to 1\n";
t_rate = 1; t_rate = 1;
} }
} }

8
eo/src/eoReduceMergeReduce.h
View file

@ -90,7 +90,7 @@ public:
// then the offspring // then the offspring
unsigned reducedOffspringSize = howManyReducedOffspring(offSize); unsigned reducedOffspringSize = howManyReducedOffspring(offSize);
if (!reducedOffspringSize) if (!reducedOffspringSize)
throw runtime_error("No offspring left after reduction!"); throw std::runtime_error("No offspring left after reduction!");
if (reducedOffspringSize != offSize) // need reduction if (reducedOffspringSize != offSize) // need reduction
reduceOffspring(_offspring, reducedOffspringSize); reduceOffspring(_offspring, reducedOffspringSize);
@ -100,7 +100,7 @@ public:
_parents.begin()+reducedParentSize); _parents.begin()+reducedParentSize);
// reduce the resulting population // reduce the resulting population
// size depends on elitism // size depstd::ends on elitism
if (elite && strongElitism) if (elite && strongElitism)
{ {
if (_parents.size() != finalPopSize-elite) if (_parents.size() != finalPopSize-elite)
@ -131,9 +131,9 @@ public:
private: private:
eoHowMany howManyElite; // if 0, no elitism at all eoHowMany howManyElite; // if 0, no elitism at all
bool strongElitism; // if false -> weak elistism bool strongElitism; // if false -> weak estd::listism
eoHowMany howManyReducedParents; // if 0, no parent in final replacement eoHowMany howManyReducedParents; // if 0, no parent in final replacement
eoHowMany howManyReducedOffspring; // if 0, runtime_error eoHowMany howManyReducedOffspring; // if 0, std::runtime_error
// the reducers // the reducers
eoReduce<EOT> & reduceParents; eoReduce<EOT> & reduceParents;
eoReduce<EOT> & reduceOffspring; eoReduce<EOT> & reduceOffspring;

6
eo/src/eoReduceSplit.h
View file

@ -215,7 +215,7 @@ public:
{ {
if (t_size < 2) if (t_size < 2)
{ {
cout << "Warning, Size for eoDetTournamentTruncateSplit adjusted to 2\n"; std::cout << "Warning, Size for eoDetTournamentTruncateSplit adjusted to 2\n";
t_size = 2; t_size = 2;
} }
} }
@ -265,12 +265,12 @@ public:
{ {
if (t_rate <= 0.5) if (t_rate <= 0.5)
{ {
cout << "Warning, Rate for eoStochTournamentTruncateSplit adjusted to 0.51\n"; std::cout << "Warning, Rate for eoStochTournamentTruncateSplit adjusted to 0.51\n";
t_rate = 0.51; t_rate = 0.51;
} }
if (t_rate > 1) if (t_rate > 1)
{ {
cout << "Warning, Rate for eoStochTournamentTruncateSplit adjusted to 1\n"; std::cout << "Warning, Rate for eoStochTournamentTruncateSplit adjusted to 1\n";
t_rate = 1; t_rate = 1;
} }
} }

2
eo/src/eoSGAGenOp.h
View file

@ -74,7 +74,7 @@ class eoSGAGenOp : public eoGenOp<EOT>
/** inherited from eoGenOp */ /** inherited from eoGenOp */
virtual unsigned max_production(void) {return 2;} virtual unsigned max_production(void) {return 2;}
virtual string className() const {return "eoSGAGenOp";} virtual std::string className() const {return "eoSGAGenOp";}
private: private:

2
eo/src/eoSGATransform.h
View file

@ -33,7 +33,7 @@
/////////////////////////////////////////////////////////////////////////////// ///////////////////////////////////////////////////////////////////////////////
// class eoSGATransform // class eoSGATransform
/////////////////////////////////////////////////////////////////////////////// ///////////////////////////////////////////////////////////////////////////////
#include <vector> // vector #include <vector> // std::vector
#include <utils/eoRNG.h> #include <utils/eoRNG.h>
#include <eoTransform.h> #include <eoTransform.h>

14
eo/src/eoSelectFactory.h
View file

@ -49,13 +49,13 @@ public:
virtual ~eoSelectFactory() {} virtual ~eoSelectFactory() {}
//@} //@}
/** Another factory methods: creates an object from an istream, reading from /** Another factory methods: creates an object from an std::istream, reading from
it whatever is needed to create the object. Usually, the format for the istream will be\\ it whatever is needed to create the object. Usually, the format for the std::istream will be\\
objectType parameter1 parameter2 ... parametern\\ objectType parameter1 parameter2 ... parametern\\
*/ */
virtual eoSelect<EOT>* make(istream& _is) { virtual eoSelect<EOT>* make(std::istream& _is) {
eoSelect<EOT> * selectPtr; eoSelect<EOT> * selectPtr;
string objectTypeStr; std::string objectTypeStr;
_is >> objectTypeStr; _is >> objectTypeStr;
// All selectors have a rate, the proportion of the original population // All selectors have a rate, the proportion of the original population
float rate; float rate;
@ -69,7 +69,7 @@ public:
if ( objectTypeStr == "eoRandomSelect" ) { if ( objectTypeStr == "eoRandomSelect" ) {
selectPtr = new eoRandomSelect<EOT>( rate ); selectPtr = new eoRandomSelect<EOT>( rate );
} else { } else {
throw runtime_error( "Incorrect selector type" ); throw std::runtime_error( "Incorrect selector type" );
} }
} }
return selectPtr; return selectPtr;
@ -77,8 +77,8 @@ public:
///@name eoObject methods ///@name eoObject methods
//@{ //@{
void printOn( ostream& _os ) const {}; void printOn( std::ostream& _os ) const {};
void readFrom( istream& _is ){}; void readFrom( std::istream& _is ){};
/** className is inherited */ /** className is inherited */
//@} //@}

12
eo/src/eoSelectFromWorth.h
View file

@ -34,14 +34,14 @@
//----------------------------------------------------------------------------- //-----------------------------------------------------------------------------
/** selects one element from a population (is an eoSelectOne) /** selects one element from a population (is an eoSelectOne)
but the selection is based on a vector of Worth that is different but the selection is based on a std::vector of Worth that is different
from the fitnesses (e.g. EO fitness is what Koza terms "raw fitness", from the fitnesses (e.g. EO fitness is what Koza terms "raw fitness",
Worth is what the selection is based upon). Worth is what the selection is based upon).
see class eoPerf2Worth: an eoStat that transforms fitnesses into Worthes see class eoPerf2Worth: an eoStat that transforms fitnesses into Worthes
Note: Worthes will not always be doubles - see some multi-objective Note: Worthes will not always be doubles - see some multi-objective
techniques where it is a pair of doubles ... techniques where it is a std::pair of doubles ...
It has to have a < operator it you want to call an existing It has to have a < operator it you want to call an existing
selector (see selector.h) - but of course you can write the whole selector (see selector.h) - but of course you can write the whole
@ -79,7 +79,7 @@ protected:
{ {
if (fitness[index] != _eo.fitness()) if (fitness[index] != _eo.fitness())
{ {
throw runtime_error("eoSelectFromWorth: fitnesses are not in sync"); throw std::runtime_error("eoSelectFromWorth: fitnesses are not in sync");
} }
} }
@ -95,7 +95,7 @@ template <class EOT, class WorthT = double>
class eoDetTournamentWorthSelect : public eoSelectFromWorth<EOT, WorthT> class eoDetTournamentWorthSelect : public eoSelectFromWorth<EOT, WorthT>
{ {
public: public:
typedef typename vector<WorthT>::iterator worthIterator; typedef typename std::vector<WorthT>::iterator worthIterator;
/* Default ctor from an eoPerf2Worth object + tournament size /* Default ctor from an eoPerf2Worth object + tournament size
*/ */
@ -134,7 +134,7 @@ template <class EOT, class WorthT = double>
class eoStochTournamentWorthSelect : public eoSelectFromWorth<EOT, WorthT> class eoStochTournamentWorthSelect : public eoSelectFromWorth<EOT, WorthT>
{ {
public: public:
typedef typename vector<WorthT>::iterator worthIterator; typedef typename std::vector<WorthT>::iterator worthIterator;
/* Default ctor from an eoPerf2Worth object + tournament rate /* Default ctor from an eoPerf2Worth object + tournament rate
*/ */
@ -172,7 +172,7 @@ template <class EOT, class WorthT = double>
class eoRouletteWorthSelect : public eoSelectFromWorth<EOT, WorthT> class eoRouletteWorthSelect : public eoSelectFromWorth<EOT, WorthT>
{ {
public: public:
typedef typename vector<WorthT>::iterator worthIterator; typedef typename std::vector<WorthT>::iterator worthIterator;
/* Default ctor from an eoPerf2Worth object /* Default ctor from an eoPerf2Worth object
*/ */

19
eo/src/eoSequentialSelect.h
View file

@ -53,8 +53,13 @@ template <class EOT> class eoSequentialSelect: public eoSelectOne<EOT>
/** Ctor: sets the current pter to MAXINT so init will take place first time /** Ctor: sets the current pter to MAXINT so init will take place first time
not very elegant, maybe ... not very elegant, maybe ...
*/ */
eoSequentialSelect(bool _ordered = true): #ifdef _MSC_VER
ordered(_ordered), current(MAXINT) {} eoSequentialSelect(bool _ordered = true)
: ordered(_ordered), current(std::MAXINT) {}
#else
eoSequentialSelect(bool _ordered = true)
: ordered(_ordered), current(MAXINT) {}
#endif
void setup(const eoPop<EOT>& _pop) void setup(const eoPop<EOT>& _pop)
{ {
@ -78,7 +83,7 @@ template <class EOT> class eoSequentialSelect: public eoSelectOne<EOT>
private: private:
bool ordered; bool ordered;
unsigned current; unsigned current;
vector<const EOT*> eoPters; std::vector<const EOT*> eoPters;
}; };
@ -99,7 +104,11 @@ template <class EOT> class eoEliteSequentialSelect: public eoSelectOne<EOT>
/** Ctor: sets the current pter to MAXINT so init will take place first time /** Ctor: sets the current pter to MAXINT so init will take place first time
not very elegant, maybe ... not very elegant, maybe ...
*/ */
#ifdef _MSC_VER
eoEliteSequentialSelect(): current(std::MAXINT) {}
#else
eoEliteSequentialSelect(): current(MAXINT) {} eoEliteSequentialSelect(): current(MAXINT) {}
#endif
void setup(const eoPop<EOT>& _pop) void setup(const eoPop<EOT>& _pop)
{ {
@ -109,7 +118,7 @@ template <class EOT> class eoEliteSequentialSelect: public eoSelectOne<EOT>
unsigned int ibest = 0; unsigned int ibest = 0;
const EOT * best = eoPters[0]; const EOT * best = eoPters[0];
if (_pop.size() == 1) if (_pop.size() == 1)
throw runtime_error("Trying eoEliteSequentialSelect with only one individual!"); throw std::runtime_error("Trying eoEliteSequentialSelect with only one individual!");
for (unsigned i=1; i<_pop.size(); i++) for (unsigned i=1; i<_pop.size(); i++)
if (*eoPters[i]>*best) if (*eoPters[i]>*best)
{ {
@ -135,7 +144,7 @@ template <class EOT> class eoEliteSequentialSelect: public eoSelectOne<EOT>
} }
private: private:
unsigned current; unsigned current;
vector<const EOT*> eoPters; std::vector<const EOT*> eoPters;
}; };

16
eo/src/eoSharing.h
View file

@ -55,10 +55,10 @@ class eoSharing : public eoPerf2Worth<EOT, double>
unsigned i, j, unsigned i, j,
pSize=_pop.size(); pSize=_pop.size();
if (pSize <= 1) if (pSize <= 1)
throw runtime_error("Apptempt to do sharing with population of size 1"); throw std::runtime_error("Apptempt to do sharing with population of size 1");
value.resize(pSize); value.resize(pSize);
vector<double> sim(pSize); // to hold the similarities std::vector<double> sim(pSize); // to hold the similarities
vector<double> distMatrix(pSize*(pSize-1)/2); // to hold the distances std::vector<double> distMatrix(pSize*(pSize-1)/2); // to hold the distances
// compute the distances // compute the distances
distMatrix(0,0)=0; distMatrix(0,0)=0;
@ -86,11 +86,11 @@ class eoSharing : public eoPerf2Worth<EOT, double>
} }
// helper class to hold distances // helper class to hold distances
class dMatrix : public vector<double> class dMatrix : public std::vector<double>
{ {
public: public:
// Ctor : sets size // Ctor : sets size
dMatrix(unsigned _s) : vector<double>(_s*(_s-1)), rSize(_s) {} dMatrix(unsigned _s) : std::vector<double>(_s*(_s-1)), rSize(_s) {}
/** simple accessor */ /** simple accessor */
double operator()(unsigned _i, unsigned _j) const double operator()(unsigned _i, unsigned _j) const
@ -105,16 +105,16 @@ class eoSharing : public eoPerf2Worth<EOT, double>
} }
/** just in case */ /** just in case */
void printOn(ostream & _os) void printOn(std::ostream & _os)
{ {
unsigned index=0; unsigned index=0;
for (unsigned i=0; i<rSize; i++) for (unsigned i=0; i<rSize; i++)
{ {
for (unsigned j=0; j<rSize; j++) for (unsigned j=0; j<rSize; j++)
_os << this->operator[](index++) << " " ; _os << this->operator[](index++) << " " ;
_os << endl; _os << std::endl;
} }
_os << endl; _os << std::endl;
} }
private: private:

6
eo/src/eoSimpleDEA.h
View file

@ -80,11 +80,11 @@ template<class EOT> class eoSimpleDEA: public eoDEA<EOT>
update(_distrib, pop); // updates distrib from _pop update(_distrib, pop); // updates distrib from _pop
} }
catch (exception& e) catch (std::exception& e)
{ {
string s = e.what(); std::string s = e.what();
s.append( " in eoSimpleDEA"); s.append( " in eoSimpleDEA");
throw runtime_error( s ); throw std::runtime_error( s );
} }
} while ( continuator( pop ) ); } while ( continuator( pop ) );
} }

6
eo/src/eoSteadyFitContinue.h
View file

@ -54,7 +54,7 @@ public:
* reached withtout improvement */ * reached withtout improvement */
virtual bool operator() ( const eoPop<EOT>& _vEO ) { virtual bool operator() ( const eoPop<EOT>& _vEO ) {
thisGeneration++; thisGeneration++;
// cout << " [" << thisGeneration << "] "; // std::cout << " [" << thisGeneration << "] ";
Fitness bestCurrentFitness = _vEO.nth_element_fitness(0); Fitness bestCurrentFitness = _vEO.nth_element_fitness(0);
if (steadyState) { // already after MinGenenerations if (steadyState) { // already after MinGenenerations
@ -63,7 +63,7 @@ public:
lastImprovement = thisGeneration; lastImprovement = thisGeneration;
} else { } else {
if (thisGeneration - lastImprovement > repSteadyGenerations) { if (thisGeneration - lastImprovement > repSteadyGenerations) {
cout << "STOP in eoSteadyFitContinue: Done " << repSteadyGenerations std::cout << "STOP in eoSteadyFitContinue: Done " << repSteadyGenerations
<< " generations without improvement\n"; << " generations without improvement\n";
return false; return false;
} }
@ -73,7 +73,7 @@ public:
steadyState = true; steadyState = true;
bestSoFar = bestCurrentFitness; bestSoFar = bestCurrentFitness;
lastImprovement = thisGeneration; lastImprovement = thisGeneration;
cout << "eoSteadyFitContinue: Done the minimum number of generations\n"; std::cout << "eoSteadyFitContinue: Done the minimum number of generations\n";
} }
} }
return true; return true;

4
eo/src/eoStochTournamentSelect.h
View file

@ -48,11 +48,11 @@ template <class EOT> class eoStochTournamentSelect: public eoSelectOne<EOT>
{ {
// consistency checks // consistency checks
if (Trate < 0.5) { if (Trate < 0.5) {
cerr << "Warning, Tournament rate should be > 0.5\nAdjusted to 0.55\n"; std::cerr << "Warning, Tournament rate should be > 0.5\nAdjusted to 0.55\n";
Trate = 0.55; Trate = 0.55;
} }
if (Trate > 1) { if (Trate > 1) {
cerr << "Warning, Tournament rate should be < 1\nAdjusted to 1\n"; std::cerr << "Warning, Tournament rate should be < 1\nAdjusted to 1\n";
Trate = 1; Trate = 1;
} }
} }

4
eo/src/eoSurviveAndDie.h
View file

@ -90,14 +90,14 @@ public:
_pop.nth_element(nbSurvive); _pop.nth_element(nbSurvive);
// copy best // copy best
_luckyGuys.resize(nbSurvive); _luckyGuys.resize(nbSurvive);
copy(_pop.begin(), _pop.begin()+nbSurvive, _luckyGuys.begin()); std::copy(_pop.begin(), _pop.begin()+nbSurvive, _luckyGuys.begin());
// erase them from pop // erase them from pop
_pop.erase(_pop.begin(), _pop.begin()+nbSurvive); _pop.erase(_pop.begin(), _pop.begin()+nbSurvive);
} }
unsigned nbRemaining = _pop.size(); unsigned nbRemaining = _pop.size();
// carefull, we can have a rate of 1 if we want to kill all remaining // carefull, we can have a rate of 1 if we want to kill all remaining
unsigned nbDie = min(howmanyDie(pSize), pSize-nbSurvive); unsigned nbDie = std::min(howmanyDie(pSize), pSize-nbSurvive);
if (nbDie > nbRemaining) if (nbDie > nbRemaining)
throw std::logic_error("eoDeterministicSurviveAndDie: Too many to kill!\n"); throw std::logic_error("eoDeterministicSurviveAndDie: Too many to kill!\n");

4
eo/src/eoToricCellularEasyEA.h
View file

@ -26,7 +26,7 @@
#include <eoCellularEasyEA.h> #include <eoCellularEasyEA.h>
#include <math.h> #include <cmath>
template <class EOT> class eoToricCellularEasyEA : public eoCellularEasyEA <EOT> { template <class EOT> class eoToricCellularEasyEA : public eoCellularEasyEA <EOT> {
@ -71,7 +71,7 @@ public :
virtual eoPop <EOT> neighbours (const eoPop <EOT> & pop, int rank) { virtual eoPop <EOT> neighbours (const eoPop <EOT> & pop, int rank) {
int dim2 = pop.size () ; int dim2 = pop.size () ;
int dim = (int) sqrt (dim2) ; int dim = (int) std::sqrt ( (double) dim2) ;
int j = rank ; int j = rank ;
eoPop <EOT> neigh ; eoPop <EOT> neigh ;

2
eo/src/eoTruncatedSelectMany.h
View file

@ -93,7 +93,7 @@ class eoTruncatedSelectMany : public eoSelect<EOT>
else else
{ {
// at the moment, brute force (rush rush, no good) // at the moment, brute force (rush rush, no good)
// what we would need otherwise is a vector<EOT &> class // what we would need otherwise is a std::vector<EOT &> class
// and selectors that act on such a thing // and selectors that act on such a thing
eoPop<EOT> tmpPop = _source; // hum hum, could be a pain in the ass eoPop<EOT> tmpPop = _source; // hum hum, could be a pain in the ass

30
eo/src/eoVariableLengthCrossover.h
View file

@ -21,7 +21,7 @@
Contact: todos@geneura.ugr.es, http://geneura.ugr.es Contact: todos@geneura.ugr.es, http://geneura.ugr.es
Marc.Schoenauer@polytechnique.fr Marc.Schoenauer@polytechnique.fr
mak@dhi.dk mak@dhi.dk
CVS Info: $Date: 2001-09-04 06:51:59 $ $Header: /home/nojhan/dev/eodev/eodev_cvs/eo/src/eoVariableLengthCrossover.h,v 1.7 2001-09-04 06:51:59 evomarc Exp $ $Author: evomarc $ CVS Info: $Date: 2003-02-27 19:25:48 $ $Header: /home/nojhan/dev/eodev/eodev_cvs/eo/src/eoVariableLengthCrossover.h,v 1.8 2003-02-27 19:25:48 okoenig Exp $ $Author: okoenig $
*/ */
//----------------------------------------------------------------------------- //-----------------------------------------------------------------------------
@ -45,7 +45,7 @@ class eoAtomExchange : public eoBF<unsigned, Atom &, bool>
public: public:
// a function to initlialize - to be called before every crossover // a function to initlialize - to be called before every crossover
virtual void randomize(unsigned int, unsigned int){} virtual void randomize(unsigned int, unsigned int){}
virtual string className() const=0; virtual std::string className() const=0;
}; };
/** Uniform crossover - well, not really for FixedLength */ /** Uniform crossover - well, not really for FixedLength */
@ -70,11 +70,11 @@ public:
return mask[_i]; return mask[_i];
} }
virtual string className() const {return "eoUniformAtomExchange";} virtual std::string className() const {return "eoUniformAtomExchange";}
private: private:
double rate; double rate;
vector<bool> mask; std::vector<bool> mask;
}; };
@ -124,7 +124,7 @@ public :
&& (index<10000) ); && (index<10000) );
if (index >= 10000) if (index >= 10000)
{ {
cout << "Warning: impossible to generate individual of the right size in 10000 trials\n"; std::cout << "Warning: impossible to generate individual of the right size in 10000 trials\n";
return false; return false;
} }
// here we know we have the right sizes: do the actual exchange // here we know we have the right sizes: do the actual exchange
@ -148,12 +148,12 @@ public :
return true; // should we test that? Yes, but no time now return true; // should we test that? Yes, but no time now
} }
virtual string className() const virtual std::string className() const
{ {
char s[1024]; char s[1024];
ostrstream os(s, 1022); std::ostrstream os(s, 1022);
os << "eoVlAtomExchangeQuadOp(" << atomExchange.className() << ")" << ends; os << "eoVlAtomExchangeQuadOp(" << atomExchange.className() << ")" << std::ends;
return string(s); return std::string(s);
} }
private: private:
@ -188,12 +188,12 @@ public :
return changed; // should we test that? Yes, but no time now return changed; // should we test that? Yes, but no time now
} }
virtual string className() const virtual std::string className() const
{ {
char s[1024]; char s[1024];
ostrstream os(s, 1022); std::ostrstream os(s, 1022);
os << "eoInnerExchangeQuadOp(" << atomExchange.className() << ")" << ends; os << "eoInnerExchangeQuadOp(" << atomExchange.className() << ")" << std::ends;
return string(s); return std::string(s);
} }
private: private:
float rate; float rate;
@ -250,7 +250,7 @@ public :
&& (index<10000) ); && (index<10000) );
if (index >= 10000) if (index >= 10000)
{ {
cout << "Warning: impossible to generate individual of the right size in 10000 trials\n"; std::cout << "Warning: impossible to generate individual of the right size in 10000 trials\n";
return false; return false;
} }
@ -318,7 +318,7 @@ public :
// this while condition is not optimal, as it may take some time // this while condition is not optimal, as it may take some time
if (index >= 10000) if (index >= 10000)
{ {
cout << "Warning: impossible to generate individual of the right size in 10000 trials\n"; std::cout << "Warning: impossible to generate individual of the right size in 10000 trials\n";
return false; return false;
} }

16
eo/src/eoVariableLengthMutation.h
View file

@ -21,7 +21,7 @@
Contact: todos@geneura.ugr.es, http://geneura.ugr.es Contact: todos@geneura.ugr.es, http://geneura.ugr.es
Marc.Schoenauer@polytechnique.fr Marc.Schoenauer@polytechnique.fr
mak@dhi.dk mak@dhi.dk
CVS Info: $Date: 2001-09-04 06:51:59 $ $Version$ $Author: evomarc $ CVS Info: $Date: 2003-02-27 19:25:48 $ $Version$ $Author: okoenig $
*/ */
//----------------------------------------------------------------------------- //-----------------------------------------------------------------------------
@ -72,7 +72,7 @@ public :
return true; return true;
} }
virtual string className() const { return "eoVlAddMutation"; } virtual std::string className() const { return "eoVlAddMutation"; }
private: private:
unsigned nMax; unsigned nMax;
@ -84,7 +84,7 @@ template <class EOT>
class eoGeneDelChooser : public eoUF<EOT &, unsigned int> class eoGeneDelChooser : public eoUF<EOT &, unsigned int>
{ {
public: public:
virtual string className() const =0; virtual std::string className() const =0;
}; };
@ -98,7 +98,7 @@ public:
{ {
return eo::rng.random(_eo.size()); return eo::rng.random(_eo.size());
} }
virtual string className() const { return "eoUniformGeneChooser"; } virtual std::string className() const { return "eoUniformGeneChooser"; }
}; };
/** Deletion of a gene /** Deletion of a gene
@ -139,12 +139,12 @@ public :
return true; return true;
} }
virtual string className() const virtual std::string className() const
{ {
char s[1024]; char s[1024];
ostrstream os(s, 1022); std::ostrstream os(s, 1022);
os << "eoVlDelMutation(" << chooser.className() << ")" << ends; os << "eoVlDelMutation(" << chooser.className() << ")" << std::ends;
return string(s); return std::string(s);
} }
private: private:

22
eo/src/eoVector.h
View file

@ -22,7 +22,7 @@
Marc.Schoenauer@polytechnique.fr Marc.Schoenauer@polytechnique.fr
mak@dhi.dk mak@dhi.dk
CVS Info: $Date: 2002-10-18 11:39:05 $ $Header: /home/nojhan/dev/eodev/eodev_cvs/eo/src/eoVector.h,v 1.13 2002-10-18 11:39:05 jeggermo Exp $ $Author: jeggermo $ CVS Info: $Date: 2003-02-27 19:25:47 $ $Header: /home/nojhan/dev/eodev/eodev_cvs/eo/src/eoVector.h,v 1.14 2003-02-27 19:25:47 okoenig Exp $ $Author: okoenig $
*/ */
//----------------------------------------------------------------------------- //-----------------------------------------------------------------------------
@ -36,9 +36,9 @@
/** /**
Base class for fixed length chromosomes, just derives from EO and vector and Base class for fixed length chromosomes, just derives from EO and std::vector and
redirects the smaller than operator to EO (fitness based comparison). GeneType redirects the smaller than operator to EO (fitness based comparison). GeneType
must have the following methods: void ctor (needed for the vector<>), copy ctor, must have the following methods: void ctor (needed for the std::vector<>), copy ctor,
*/ */
@ -56,17 +56,17 @@ class eoVector : public EO<FitT>, public std::vector<GeneType>
/// copy ctor abstracting from the FitT /// copy ctor abstracting from the FitT
template <class OtherFitnessType> template <class OtherFitnessType>
eoVector(const eoVector<OtherFitnessType, GeneType>& _vec) : vector<GeneType>(_vec) eoVector(const eoVector<OtherFitnessType, GeneType>& _vec) : std::vector<GeneType>(_vec)
{} {}
// we can't have a Ctor from a vector, it would create ambiguity // we can't have a Ctor from a std::vector, it would create ambiguity
// with the copy Ctor // with the copy Ctor
void value(const std::vector<GeneType>& _v) void value(const std::vector<GeneType>& _v)
{ {
if (_v.size() != size()) // safety check if (_v.size() != size()) // safety check
{ {
if (size()) // NOT an initial empty vector if (size()) // NOT an initial empty std::vector
cout << "Warning: Changing size in eoVector assignation"<<endl; std::cout << "Warning: Changing size in eoVector assignation"<<std::endl;
resize(_v.size()); resize(_v.size());
} }
@ -74,14 +74,14 @@ class eoVector : public EO<FitT>, public std::vector<GeneType>
invalidate(); invalidate();
} }
/// to avoid conflicts between EO::operator< and vector<GeneType>::operator< /// to avoid conflicts between EO::operator< and std::vector<GeneType>::operator<
bool operator<(const eoVector<FitT, GeneType>& _eo) const bool operator<(const eoVector<FitT, GeneType>& _eo) const
{ {
return EO<FitT>::operator<(_eo); return EO<FitT>::operator<(_eo);
} }
/// printing... /// printing...
virtual void printOn(ostream& os) const virtual void printOn(std::ostream& os) const
{ {
EO<FitT>::printOn(os); EO<FitT>::printOn(os);
os << ' '; os << ' ';
@ -92,7 +92,7 @@ class eoVector : public EO<FitT>, public std::vector<GeneType>
} }
/// reading... /// reading...
virtual void readFrom(istream& is) virtual void readFrom(std::istream& is)
{ {
EO<FitT>::readFrom(is); EO<FitT>::readFrom(is);
@ -111,7 +111,7 @@ class eoVector : public EO<FitT>, public std::vector<GeneType>
} }
}; };
/// to avoid conflicts between EO::operator< and vector<double>::operator< /// to avoid conflicts between EO::operator< and std::vector<double>::operator<
template <class FitT, class GeneType> template <class FitT, class GeneType>
bool operator<(const eoVector<FitT, GeneType>& _eo1, const eoVector<FitT, GeneType>& _eo2) bool operator<(const eoVector<FitT, GeneType>& _eo1, const eoVector<FitT, GeneType>& _eo2)
{ {

2
eo/src/es.h
View file

@ -35,7 +35,7 @@
// contains the include specific to real representations, i.e. in src/es dir // contains the include specific to real representations, i.e. in src/es dir
//----------------------------------------------------------------------------- //-----------------------------------------------------------------------------
// the genotypes - from plain vector<double> to full correlated mutation // the genotypes - from plain std::vector<double> to full correlated mutation
#include <es/eoReal.h> #include <es/eoReal.h>
#include <es/eoEsSimple.h> #include <es/eoEsSimple.h>
#include <es/eoEsStdev.h> #include <es/eoEsStdev.h>

4
eo/src/es/eoEsChromInit.h
View file

@ -46,7 +46,7 @@
eoReal just an eoVector<double> eoReal just an eoVector<double>
eoEsSimple + one self-adapting single sigma for all variables eoEsSimple + one self-adapting single sigma for all variables
eoEsStdev a whole vector of self-adapting sigmas eoEsStdev a whole std::vector of self-adapting sigmas
eoEsFull a full self-adapting correlation matrix eoEsFull a full self-adapting correlation matrix
@see eoReal eoEsSimple eoEsStdev eoEsFull eoInit @see eoReal eoEsSimple eoEsStdev eoEsFull eoInit
@ -84,7 +84,7 @@ private :
result.stdev = sigma; result.stdev = sigma;
} }
// Adaptive mutation through a vector of sigmas // Adaptive mutation through a std::vector of sigmas
void create_self_adapt(eoEsStdev<FitT>& result) void create_self_adapt(eoEsStdev<FitT>& result)
{ {
unsigned theSize = eoRealInitBounded<EOT>::size(); unsigned theSize = eoRealInitBounded<EOT>::size();

6
eo/src/es/eoEsFull.h
View file

@ -60,7 +60,7 @@ class eoEsFull : public eoVector<Fit, double>
os << ' '; os << ' ';
} }
void readFrom(istream& is) void readFrom(std::istream& is)
{ {
eoVector<Fit,double>::readFrom(is); eoVector<Fit,double>::readFrom(is);
@ -76,8 +76,8 @@ class eoEsFull : public eoVector<Fit, double>
is >> correlations[i]; is >> correlations[i];
} }
vector<double> stdevs; std::vector<double> stdevs;
vector<double> correlations; std::vector<double> correlations;
}; };

2
eo/src/es/eoEsGlobalXover.h
View file

@ -53,7 +53,7 @@ public:
crossObj(_crossObj), crossMut(_crossMut) {} crossObj(_crossObj), crossMut(_crossMut) {}
/// The class name. Used to display statistics /// The class name. Used to display statistics
virtual string className() const { return "eoEsGlobalXover"; } virtual std::string className() const { return "eoEsGlobalXover"; }
/// The TOTAL number of offspring (here = nb of parents modified in place) /// The TOTAL number of offspring (here = nb of parents modified in place)
unsigned max_production(void) { return 1; } unsigned max_production(void) { return 1; }

10
eo/src/es/eoEsMutate.h
View file

@ -84,7 +84,7 @@ public:
/** Inherited from eoObject /** Inherited from eoObject
@see eoObject @see eoObject
*/ */
virtual string className() const {return "eoESMutate";}; virtual std::string className() const {return "eoESMutate";};
/** /**
Mutate eoEsSimple Mutate eoEsSimple
@ -191,7 +191,7 @@ public:
unsigned k, n1, n2; unsigned k, n1, n2;
double d1,d2, S, C; double d1,d2, S, C;
vector<double> VarStp(_eo.size()); std::vector<double> VarStp(_eo.size());
for (i = 0; i < _eo.size(); i++) for (i = 0; i < _eo.size(); i++)
VarStp[i] = _eo.stdevs[i] * rng.normal(); VarStp[i] = _eo.stdevs[i] * rng.normal();
@ -230,7 +230,7 @@ public:
unsigned size = bounds.size(); unsigned size = bounds.size();
TauLcl = _init.TauLcl(); TauLcl = _init.TauLcl();
TauLcl /= sqrt(2*(double) size); TauLcl /= sqrt(2*(double) size);
cout << "Init<eoEsSimple>: tau local " << TauLcl << endl; std::cout << "Init<eoEsSimple>: tau local " << TauLcl << std::endl;
} }
void init(eoEsStdev<FitT>, eoEsMutationInit& _init) void init(eoEsStdev<FitT>, eoEsMutationInit& _init)
@ -243,14 +243,14 @@ public:
// renormalization // renormalization
TauLcl /= sqrt( 2.0 * sqrt( (double)size ) ); TauLcl /= sqrt( 2.0 * sqrt( (double)size ) );
TauGlb /= sqrt( 2.0 * ( (double) size ) ); TauGlb /= sqrt( 2.0 * ( (double) size ) );
cout << "Init<eoStDev>: tau local " << TauLcl << " et global " << TauGlb << endl; std::cout << "Init<eoStDev>: tau local " << TauLcl << " et global " << TauGlb << std::endl;
} }
void init(eoEsFull<FitT>, eoEsMutationInit& _init) void init(eoEsFull<FitT>, eoEsMutationInit& _init)
{ {
init(eoEsStdev<FitT>(), _init); init(eoEsStdev<FitT>(), _init);
TauBeta = _init.TauBeta(); TauBeta = _init.TauBeta();
cout << "Init<eoEsFull>: tau local " << TauLcl << " et global " << TauGlb << endl; std::cout << "Init<eoEsFull>: tau local " << TauLcl << " et global " << TauGlb << std::endl;
} }
// the data // the data

2
eo/src/es/eoEsSimple.h
View file

@ -61,7 +61,7 @@ public :
os << ' ' << stdev << ' '; os << ' ' << stdev << ' ';
} }
void readFrom(istream& is) void readFrom(std::istream& is)
{ {
eoVector<Fit,double>::readFrom(is); eoVector<Fit,double>::readFrom(is);

2
eo/src/es/eoEsStandardXover.h
View file

@ -55,7 +55,7 @@ public:
crossObj(_crossObj), crossMut(_crossMut) {} crossObj(_crossObj), crossMut(_crossMut) {}
/// The class name. Used to display statistics /// The class name. Used to display statistics
virtual string className() const { return "eoEsStandardXover"; } virtual std::string className() const { return "eoEsStandardXover"; }
/** /**
* modifies one parents in the populator * modifies one parents in the populator

4
eo/src/es/eoEsStdev.h
View file

@ -57,7 +57,7 @@ class eoEsStdev : public eoVector<Fit, double>
os << ' '; os << ' ';
} }
void readFrom(istream& is) void readFrom(std::istream& is)
{ {
eoVector<Fit,double>::readFrom(is); eoVector<Fit,double>::readFrom(is);
stdevs.resize(size()); stdevs.resize(size());
@ -68,7 +68,7 @@ class eoEsStdev : public eoVector<Fit, double>
} }
vector<double> stdevs; std::vector<double> stdevs;
}; };
#endif #endif

14
eo/src/es/eoNormalMutation.h
View file

@ -36,7 +36,7 @@
#include <utils/eoRealBounds.h> #include <utils/eoRealBounds.h>
//----------------------------------------------------------------------------- //-----------------------------------------------------------------------------
/** Simple normal mutation of a vector of real values. /** Simple normal mutation of a std::vector of real values.
* The stDev is fixed - but it is passed ans stored as a reference, * The stDev is fixed - but it is passed ans stored as a reference,
* to enable dynamic mutations (see eoOenFithMutation below). * to enable dynamic mutations (see eoOenFithMutation below).
* *
@ -69,7 +69,7 @@ template<class EOT> class eoNormalMutation: public eoMonOp<EOT>
sigma(_sigma), bounds(_bounds), p_change(_p_change) {} sigma(_sigma), bounds(_bounds), p_change(_p_change) {}
/** The class name */ /** The class name */
virtual string className() const { return "eoNormalMutation"; } virtual std::string className() const { return "eoNormalMutation"; }
/** /**
* Do it! * Do it!
@ -129,11 +129,11 @@ public:
{ {
// minimal check // minimal check
if (updateFactor>=1) if (updateFactor>=1)
throw runtime_error("Update factor must be < 1 in eoOneFifthMutation"); throw std::runtime_error("Update factor must be < 1 in eoOneFifthMutation");
} }
/** The class name */ /** The class name */
virtual string className() const { return "eoOneFifthMutation"; } virtual std::string className() const { return "eoOneFifthMutation"; }
/** /**
* Do it! * Do it!
@ -192,9 +192,9 @@ private:
eoEvalFunc<EOT> & eval; eoEvalFunc<EOT> & eval;
double threshold; // 1/5 ! double threshold; // 1/5 !
double updateFactor ; // the multiplicative factor double updateFactor ; // the multiplicative factor
vector<unsigned> nbMut; // total number of mutations per gen std::vector<unsigned> nbMut; // total number of mutations per gen
vector<unsigned> nbSuccess; // number of successful mutations per gen std::vector<unsigned> nbSuccess; // number of successful mutations per gen
unsigned genIndex ; // current index in vectors (circular) unsigned genIndex ; // current index in std::vectors (circular)
}; };

8
eo/src/es/eoReal.h
View file

@ -26,8 +26,8 @@
//----------------------------------------------------------------------------- //-----------------------------------------------------------------------------
#include <iostream> // ostream, istream #include <iostream> // std::ostream, std::istream
#include <string> // string #include <string> // std::string
#include <eoVector.h> #include <eoVector.h>
@ -40,13 +40,13 @@ template <class FitT> class eoReal: public eoVector<FitT, double>
/** /**
* (Default) Constructor. * (Default) Constructor.
* @param size Size of the vector * @param size Size of the std::vector
*/ */
eoReal(unsigned size = 0, double value = 0.0): eoReal(unsigned size = 0, double value = 0.0):
eoVector<FitT, double>(size, value) {} eoVector<FitT, double>(size, value) {}
/// My class name. /// My class name.
virtual string className() const virtual std::string className() const
{ {
return "eoReal"; return "eoReal";
} }

6
eo/src/es/eoRealAtomXover.h
View file

@ -1,7 +1,7 @@
/** -*- mode: c++; c-indent-level: 4; c++-member-init-indent: 8; comment-column: 35; -*- /** -*- mode: c++; c-indent-level: 4; c++-member-init-indent: 8; comment-column: 35; -*-
//----------------------------------------------------------------------------- //-----------------------------------------------------------------------------
// eoRealAtomXover.h : helper classes for vector<real> crossover // eoRealAtomXover.h : helper classes for std::vector<real> crossover
// (c) Marc Schoenauer 2001 // (c) Marc Schoenauer 2001
This library is free software; you can redistribute it and/or This library is free software; you can redistribute it and/or
@ -47,7 +47,7 @@ public:
eoDoubleExchange() {} eoDoubleExchange() {}
/// The class name. Used to display statistics /// The class name. Used to display statistics
virtual string className() const { return "eoDoubleExchange"; } virtual std::string className() const { return "eoDoubleExchange"; }
/** /**
Exchanges or not the values Exchanges or not the values
@ -77,7 +77,7 @@ public:
eoDoubleIntermediate() {} eoDoubleIntermediate() {}
/// The class name. Used to display statistics /// The class name. Used to display statistics
virtual string className() const { return "eoDoubleIntermediate"; } virtual std::string className() const { return "eoDoubleIntermediate"; }
/** /**
Linear combination of both parents Linear combination of both parents

4
eo/src/es/eoRealInitBounded.h
View file

@ -33,7 +33,7 @@
#include <es/eoReal.h> #include <es/eoReal.h>
#include <utils/eoRealVectorBounds.h> #include <utils/eoRealVectorBounds.h>
/** Simple initialization for any EOT that derives from vector<double> /** Simple initialization for any EOT that derives from std::vector<double>
* uniformly in some bounds * uniformly in some bounds
*/ */
template <class EOT> template <class EOT>
@ -44,7 +44,7 @@ class eoRealInitBounded : public eoInit<EOT>
eoRealInitBounded(eoRealVectorBounds & _bounds):bounds(_bounds) eoRealInitBounded(eoRealVectorBounds & _bounds):bounds(_bounds)
{ {
if (!bounds.isBounded()) if (!bounds.isBounded())
throw runtime_error("Needs bounded bounds to initialize a vector<double>"); throw std::runtime_error("Needs bounded bounds to initialize a std::vector<double>");
} }
/** simply passes the argument to the uniform method of the bounds */ /** simply passes the argument to the uniform method of the bounds */

72
eo/src/es/eoRealOp.h
View file

@ -35,7 +35,7 @@
//----------------------------------------------------------------------------- //-----------------------------------------------------------------------------
/** eoUniformMutation --> changes all values of the vector /** eoUniformMutation --> changes all values of the std::vector
by uniform choice with range epsilon by uniform choice with range epsilon
with probability p_change per variable with probability p_change per variable
\class eoUniformMutation eoRealOp.h Tutorial/eoRealOp.h \class eoUniformMutation eoRealOp.h Tutorial/eoRealOp.h
@ -81,13 +81,13 @@ template<class EOT> class eoUniformMutation: public eoMonOp<EOT>
* @param _p_change the VECTOR of probabilities for each coordinates * @param _p_change the VECTOR of probabilities for each coordinates
*/ */
eoUniformMutation(eoRealVectorBounds & _bounds, eoUniformMutation(eoRealVectorBounds & _bounds,
const vector<double>& _epsilon, const std::vector<double>& _epsilon,
const vector<double>& _p_change): const std::vector<double>& _p_change):
homogeneous(false), bounds(_bounds), epsilon(_epsilon), homogeneous(false), bounds(_bounds), epsilon(_epsilon),
p_change(_p_change) {} p_change(_p_change) {}
/// The class name. /// The class name.
virtual string className() const { return "eoUniformMutation"; } virtual std::string className() const { return "eoUniformMutation"; }
/** /**
* Do it! * Do it!
@ -109,7 +109,7 @@ template<class EOT> class eoUniformMutation: public eoMonOp<EOT>
{ {
// sanity check ? // sanity check ?
if (_eo.size() != bounds.size()) if (_eo.size() != bounds.size())
throw runtime_error("Invalid size of indi in eoUniformMutation"); throw std::runtime_error("Invalid size of indi in eoUniformMutation");
for (unsigned lieu=0; lieu<_eo.size(); lieu++) for (unsigned lieu=0; lieu<_eo.size(); lieu++)
if (rng.flip(p_change[lieu])) if (rng.flip(p_change[lieu]))
@ -118,9 +118,9 @@ template<class EOT> class eoUniformMutation: public eoMonOp<EOT>
double emin = _eo[lieu]-epsilon[lieu]; double emin = _eo[lieu]-epsilon[lieu];
double emax = _eo[lieu]+epsilon[lieu]; double emax = _eo[lieu]+epsilon[lieu];
if (bounds.isMinBounded(lieu)) if (bounds.isMinBounded(lieu))
emin = max(bounds.minimum(lieu), emin); emin = std::max(bounds.minimum(lieu), emin);
if (bounds.isMaxBounded(lieu)) if (bounds.isMaxBounded(lieu))
emax = min(bounds.maximum(lieu), emax); emax = std::min(bounds.maximum(lieu), emax);
_eo[lieu] = emin + (emax-emin)*rng.uniform(); _eo[lieu] = emin + (emax-emin)*rng.uniform();
hasChanged = true; hasChanged = true;
} }
@ -131,11 +131,11 @@ template<class EOT> class eoUniformMutation: public eoMonOp<EOT>
private: private:
bool homogeneous; // == no bounds passed in the ctor bool homogeneous; // == no bounds passed in the ctor
eoRealVectorBounds & bounds; eoRealVectorBounds & bounds;
vector<double> epsilon; // the ranges for mutation std::vector<double> epsilon; // the ranges for mutation
vector<double> p_change; // the proba that each variable is modified std::vector<double> p_change; // the proba that each variable is modified
}; };
/** eoDetUniformMutation --> changes exactly k values of the vector /** eoDetUniformMutation --> changes exactly k values of the std::vector
by uniform choice with range epsilon by uniform choice with range epsilon
\class eoDetUniformMutation eoRealOp.h Tutorial/eoRealOp.h \class eoDetUniformMutation eoRealOp.h Tutorial/eoRealOp.h
\ingroup parameteric \ingroup parameteric
@ -173,13 +173,13 @@ template<class EOT> class eoDetUniformMutation: public eoMonOp<EOT>
} }
/** /**
* Constructor with bounds and full vector of epsilon * Constructor with bounds and full std::vector of epsilon
* @param _bounds an eoRealVectorBounds that contains the bounds * @param _bounds an eoRealVectorBounds that contains the bounds
* @param _epsilon the VECTOR of ranges for uniform mutation * @param _epsilon the VECTOR of ranges for uniform mutation
* @param number of coordinate to modify * @param number of coordinate to modify
*/ */
eoDetUniformMutation(eoRealVectorBounds & _bounds, eoDetUniformMutation(eoRealVectorBounds & _bounds,
const vector<double>& _epsilon, const std::vector<double>& _epsilon,
const unsigned& _no = 1): const unsigned& _no = 1):
homogeneous(false), bounds(_bounds), epsilon(_epsilon), no(_no) homogeneous(false), bounds(_bounds), epsilon(_epsilon), no(_no)
{ {
@ -190,7 +190,7 @@ template<class EOT> class eoDetUniformMutation: public eoMonOp<EOT>
} }
/// The class name. /// The class name.
virtual string className() const { return "eoDetUniformMutation"; } virtual std::string className() const { return "eoDetUniformMutation"; }
/** /**
* Do it! * Do it!
@ -209,7 +209,7 @@ template<class EOT> class eoDetUniformMutation: public eoMonOp<EOT>
{ {
// sanity check ? // sanity check ?
if (_eo.size() != bounds.size()) if (_eo.size() != bounds.size())
throw runtime_error("Invalid size of indi in eoDetUniformMutation"); throw std::runtime_error("Invalid size of indi in eoDetUniformMutation");
for (unsigned i=0; i<no; i++) for (unsigned i=0; i<no; i++)
{ {
unsigned lieu = rng.random(_eo.size()); unsigned lieu = rng.random(_eo.size());
@ -219,9 +219,9 @@ template<class EOT> class eoDetUniformMutation: public eoMonOp<EOT>
double emin = _eo[lieu]-epsilon[lieu]; double emin = _eo[lieu]-epsilon[lieu];
double emax = _eo[lieu]+epsilon[lieu]; double emax = _eo[lieu]+epsilon[lieu];
if (bounds.isMinBounded(lieu)) if (bounds.isMinBounded(lieu))
emin = max(bounds.minimum(lieu), emin); emin = std::max(bounds.minimum(lieu), emin);
if (bounds.isMaxBounded(lieu)) if (bounds.isMaxBounded(lieu))
emax = min(bounds.maximum(lieu), emax); emax = std::min(bounds.maximum(lieu), emax);
_eo[lieu] = emin + (emax-emin)*rng.uniform(); _eo[lieu] = emin + (emax-emin)*rng.uniform();
} }
} }
@ -231,7 +231,7 @@ template<class EOT> class eoDetUniformMutation: public eoMonOp<EOT>
private: private:
bool homogeneous; // == no bounds passed in the ctor bool homogeneous; // == no bounds passed in the ctor
eoRealVectorBounds & bounds; eoRealVectorBounds & bounds;
vector<double> epsilon; // the ranges of mutation std::vector<double> epsilon; // the ranges of mutation
unsigned no; unsigned no;
}; };
@ -272,7 +272,7 @@ template<class EOT> class eoSegmentCrossover: public eoQuadOp<EOT>
bounds(_bounds), alpha(_alpha), range(1+2*_alpha) {} bounds(_bounds), alpha(_alpha), range(1+2*_alpha) {}
/// The class name. /// The class name.
virtual string className() const { return "eoSegmentCrossover"; } virtual std::string className() const { return "eoSegmentCrossover"; }
/** /**
* segment crossover - modifies both parents * segment crossover - modifies both parents
@ -294,18 +294,18 @@ template<class EOT> class eoSegmentCrossover: public eoQuadOp<EOT>
r1=_eo1[i]; r1=_eo1[i];
r2=_eo2[i]; r2=_eo2[i];
if (r1 != r2) { // otherwise you'll get NAN's if (r1 != r2) { // otherwise you'll get NAN's
double rmin = min(r1, r2); double rmin = std::min(r1, r2);
double rmax = max(r1, r2); double rmax = std::max(r1, r2);
double length = rmax - rmin; double length = rmax - rmin;
if (bounds.isMinBounded(i)) if (bounds.isMinBounded(i))
{ {
alphaMin = max(alphaMin, (bounds.minimum(i)-rmin)/length); alphaMin = std::max(alphaMin, (bounds.minimum(i)-rmin)/length);
alphaMax = min(alphaMax, (rmax-bounds.minimum(i))/length); alphaMax = std::min(alphaMax, (rmax-bounds.minimum(i))/length);
} }
if (bounds.isMaxBounded(i)) if (bounds.isMaxBounded(i))
{ {
alphaMax = min(alphaMax, (bounds.maximum(i)-rmin)/length); alphaMax = std::min(alphaMax, (bounds.maximum(i)-rmin)/length);
alphaMin = max(alphaMin, (rmax-bounds.maximum(i))/length); alphaMin = std::max(alphaMin, (rmax-bounds.maximum(i))/length);
} }
} }
} }
@ -350,7 +350,7 @@ template<class EOT> class eoHypercubeCrossover: public eoQuadOp<EOT>
bounds(eoDummyVectorNoBounds), alpha(_alpha), range(1+2*_alpha) bounds(eoDummyVectorNoBounds), alpha(_alpha), range(1+2*_alpha)
{ {
if (_alpha < 0) if (_alpha < 0)
throw runtime_error("BLX coefficient should be positive"); throw std::runtime_error("BLX coefficient should be positive");
} }
/** /**
@ -366,11 +366,11 @@ template<class EOT> class eoHypercubeCrossover: public eoQuadOp<EOT>
bounds(_bounds), alpha(_alpha), range(1+2*_alpha) bounds(_bounds), alpha(_alpha), range(1+2*_alpha)
{ {
if (_alpha < 0) if (_alpha < 0)
throw runtime_error("BLX coefficient should be positive"); throw std::runtime_error("BLX coefficient should be positive");
} }
/// The class name. /// The class name.
virtual string className() const { return "eoHypercubeCrossover"; } virtual std::string className() const { return "eoHypercubeCrossover"; }
/** /**
* hypercube crossover - modifies both parents * hypercube crossover - modifies both parents
@ -402,8 +402,8 @@ template<class EOT> class eoHypercubeCrossover: public eoQuadOp<EOT>
r1=_eo1[i]; r1=_eo1[i];
r2=_eo2[i]; r2=_eo2[i];
if (r1 != r2) { // otherwise do nothing if (r1 != r2) { // otherwise do nothing
double rmin = min(r1, r2); double rmin = std::min(r1, r2);
double rmax = max(r1, r2); double rmax = std::max(r1, r2);
// compute min and max for object variables // compute min and max for object variables
double objMin = -alpha * rmax + (1+alpha) * rmin; double objMin = -alpha * rmax + (1+alpha) * rmin;
@ -412,11 +412,11 @@ template<class EOT> class eoHypercubeCrossover: public eoQuadOp<EOT>
// first find the limits on the alpha's // first find the limits on the alpha's
if (bounds.isMinBounded(i)) if (bounds.isMinBounded(i))
{ {
objMin = max(objMin, bounds.minimum(i)); objMin = std::max(objMin, bounds.minimum(i));
} }
if (bounds.isMaxBounded(i)) if (bounds.isMaxBounded(i))
{ {
objMax = min(objMax, bounds.maximum(i)); objMax = std::min(objMax, bounds.maximum(i));
} }
// then draw variables // then draw variables
double median = (objMin+objMax)/2.0; // uniform within bounds double median = (objMin+objMax)/2.0; // uniform within bounds
@ -464,22 +464,22 @@ template<class EOT> class eoRealUXover: public eoQuadOp<EOT>
eoRealUXover(const float& _preference = 0.5): preference(_preference) eoRealUXover(const float& _preference = 0.5): preference(_preference)
{ {
if ( (_preference <= 0.0) || (_preference >= 1.0) ) if ( (_preference <= 0.0) || (_preference >= 1.0) )
runtime_error("UxOver --> invalid preference"); std::runtime_error("UxOver --> invalid preference");
} }
/// The class name. /// The class name.
virtual string className() const { return "eoRealUXover"; } virtual std::string className() const { return "eoRealUXover"; }
/** /**
* Uniform crossover for real vectors * Uniform crossover for real std::vectors
* @param _eo1 The first parent * @param _eo1 The first parent
* @param _eo2 The second parent * @param _eo2 The second parent
* @runtime_error if sizes don't match * @std::runtime_error if sizes don't match
*/ */
bool operator()(EOT& _eo1, EOT& _eo2) bool operator()(EOT& _eo1, EOT& _eo2)
{ {
if ( _eo1.size() != _eo2.size()) if ( _eo1.size() != _eo2.size())
runtime_error("UxOver --> chromosomes sizes don't match" ); std::runtime_error("UxOver --> chromosomes sizes don't match" );
bool changed = false; bool changed = false;
for (unsigned int i=0; i<_eo1.size(); i++) for (unsigned int i=0; i<_eo1.size(); i++)
{ {

4
eo/src/es/make_genotype_real.h
View file

@ -37,7 +37,7 @@
/* /*
* This fuction does the initialization of what's needed for a particular * This fuction does the initialization of what's needed for a particular
* genotype (here, vector<double> == eoReal). * genotype (here, std::vector<double> == eoReal).
* It could be here tempatied only on the fitness, as it can be used to evolve * It could be here tempatied only on the fitness, as it can be used to evolve
* bitstrings with any fitness. * bitstrings with any fitness.
* However, for consistency reasons, it was finally chosen, as in * However, for consistency reasons, it was finally chosen, as in
@ -76,7 +76,7 @@ eoEsChromInit<EOT> & do_make_genotype(eoParser& _parser, eoState& _state, EOT)
// minimum check // minimum check
if ( (sigmaParam.value() < 0) ) if ( (sigmaParam.value() < 0) )
throw runtime_error("Invalid sigma"); throw std::runtime_error("Invalid sigma");
eoEsChromInit<EOT> * init = eoEsChromInit<EOT> * init =
new eoEsChromInit<EOT>(boundsParam.value(), sigmaParam.value()); new eoEsChromInit<EOT>(boundsParam.value(), sigmaParam.value());

44
eo/src/es/make_op.h
View file

@ -70,11 +70,11 @@ eoGenOp<EOT> & do_make_op(eoParameterLoader& _parser, eoState& _state, eoInit<EO
// First, decide whether the objective variables are bounded // First, decide whether the objective variables are bounded
eoValueParam<eoParamParamType>& boundsParam = _parser.createParam(eoParamParamType("(0,1)"), "objectBounds", "Bounds for variables (unbounded if absent)", 'B', "Genetic Operators"); eoValueParam<eoParamParamType>& boundsParam = _parser.createParam(eoParamParamType("(0,1)"), "objectBounds", "Bounds for variables (unbounded if absent)", 'B', "Genetic Operators");
// get initisalizer size == vector size // get initisalizer size == std::vector size
// eoRealInitBounded<EOT> * realInit = (eoRealInitBounded<EOT>*)(&_init); // eoRealInitBounded<EOT> * realInit = (eoRealInitBounded<EOT>*)(&_init);
// unsigned vecSize = realInit->theBounds().size(); // unsigned vecSize = realInit->theBounds().size();
// get vector size: safer??? // get std::vector size: safer???
EOT eoTmp; EOT eoTmp;
_init(eoTmp); _init(eoTmp);
unsigned vecSize = eoTmp.size(); unsigned vecSize = eoTmp.size();
@ -86,10 +86,10 @@ eoGenOp<EOT> & do_make_op(eoParameterLoader& _parser, eoState& _state, eoInit<EO
/////Warning: this code should probably be replaced by creating /////Warning: this code should probably be replaced by creating
///// some eoValueParam<eoRealVectorBounds> with specific implementation ///// some eoValueParam<eoRealVectorBounds> with specific implementation
//// in eoParser.cpp. At the moemnt, it is there (cf also make_genotype //// in eoParser.cpp. At the moemnt, it is there (cf also make_genotype
eoParamParamType & ppBounds = boundsParam.value(); // pair<string,vector<string> > eoParamParamType & ppBounds = boundsParam.value(); // std::pair<std::string,std::vector<std::string> >
// transform into a vector<double> // transform into a std::vector<double>
vector<double> v; std::vector<double> v;
vector<string>::iterator it; std::vector<std::string>::iterator it;
for (it=ppBounds.second.begin(); it<ppBounds.second.end(); it++) for (it=ppBounds.second.begin(); it<ppBounds.second.end(); it++)
{ {
istrstream is(it->c_str()); istrstream is(it->c_str());
@ -101,7 +101,7 @@ eoGenOp<EOT> & do_make_op(eoParameterLoader& _parser, eoState& _state, eoInit<EO
if (v.size() == 2) // a min and a max for all variables if (v.size() == 2) // a min and a max for all variables
ptBounds = new eoRealVectorBounds(vecSize, v[0], v[1]); ptBounds = new eoRealVectorBounds(vecSize, v[0], v[1]);
else // no time now else // no time now
throw runtime_error("Sorry, only unique bounds for all variables implemented at the moment. Come back later"); throw std::runtime_error("Sorry, only unique bounds for all variables implemented at the moment. Come back later");
// we need to give ownership of this pointer to somebody // we need to give ownership of this pointer to somebody
/////////// end of temporary code /////////// end of temporary code
} }
@ -113,10 +113,10 @@ eoGenOp<EOT> & do_make_op(eoParameterLoader& _parser, eoState& _state, eoInit<EO
// while Maarten codes the full tree-structured general operator input // while Maarten codes the full tree-structured general operator input
// BTW we must leave that simple version available somehow, as it is the one // BTW we must leave that simple version available somehow, as it is the one
// that 90% people use! // that 90% people use!
eoValueParam<string>& operatorParam = _parser.createParam(string("SGA"), "operator", "Description of the operator (SGA only now)", 'o', "Genetic Operators"); eoValueParam<std::string>& operatorParam = _parser.createParam(std::string("SGA"), "operator", "Description of the operator (SGA only now)", 'o', "Genetic Operators");
if (operatorParam.value() != string("SGA")) if (operatorParam.value() != std::string("SGA"))
throw runtime_error("Sorry, only SGA-like operator available right now\n"); throw std::runtime_error("Sorry, only SGA-like operator available right now\n");
// now we read Pcross and Pmut, // now we read Pcross and Pmut,
// the relative weights for all crossovers -> proportional choice // the relative weights for all crossovers -> proportional choice
@ -127,12 +127,12 @@ eoGenOp<EOT> & do_make_op(eoParameterLoader& _parser, eoState& _state, eoInit<EO
eoValueParam<double>& pCrossParam = _parser.createParam(0.6, "pCross", "Probability of Crossover", 'C', "Genetic Operators" ); eoValueParam<double>& pCrossParam = _parser.createParam(0.6, "pCross", "Probability of Crossover", 'C', "Genetic Operators" );
// minimum check // minimum check
if ( (pCrossParam.value() < 0) || (pCrossParam.value() > 1) ) if ( (pCrossParam.value() < 0) || (pCrossParam.value() > 1) )
throw runtime_error("Invalid pCross"); throw std::runtime_error("Invalid pCross");
eoValueParam<double>& pMutParam = _parser.createParam(0.1, "pMut", "Probability of Mutation", 'M', "Genetic Operators" ); eoValueParam<double>& pMutParam = _parser.createParam(0.1, "pMut", "Probability of Mutation", 'M', "Genetic Operators" );
// minimum check // minimum check
if ( (pMutParam.value() < 0) || (pMutParam.value() > 1) ) if ( (pMutParam.value() < 0) || (pMutParam.value() > 1) )
throw runtime_error("Invalid pMut"); throw std::runtime_error("Invalid pMut");
// the crossovers // the crossovers
///////////////// /////////////////
@ -140,18 +140,18 @@ eoGenOp<EOT> & do_make_op(eoParameterLoader& _parser, eoState& _state, eoInit<EO
eoValueParam<double>& segmentRateParam = _parser.createParam(double(1.0), "segmentRate", "Relative rate for segment crossover", 's', "Genetic Operators" ); eoValueParam<double>& segmentRateParam = _parser.createParam(double(1.0), "segmentRate", "Relative rate for segment crossover", 's', "Genetic Operators" );
// minimum check // minimum check
if ( (segmentRateParam.value() < 0) ) if ( (segmentRateParam.value() < 0) )
throw runtime_error("Invalid segmentRate"); throw std::runtime_error("Invalid segmentRate");
eoValueParam<double>& arithmeticRateParam = _parser.createParam(double(2.0), "arithmeticRate", "Relative rate for arithmetic crossover", 'A', "Genetic Operators" ); eoValueParam<double>& arithmeticRateParam = _parser.createParam(double(2.0), "arithmeticRate", "Relative rate for arithmetic crossover", 'A', "Genetic Operators" );
// minimum check // minimum check
if ( (arithmeticRateParam.value() < 0) ) if ( (arithmeticRateParam.value() < 0) )
throw runtime_error("Invalid arithmeticRate"); throw std::runtime_error("Invalid arithmeticRate");
// minimum check // minimum check
bool bCross = true; bool bCross = true;
if (segmentRateParam.value()+arithmeticRateParam.value()==0) if (segmentRateParam.value()+arithmeticRateParam.value()==0)
{ {
cerr << "Warning: no crossover" << endl; std::cerr << "Warning: no crossover" << std::endl;
bCross = false; bCross = false;
} }
@ -181,37 +181,37 @@ eoGenOp<EOT> & do_make_op(eoParameterLoader& _parser, eoState& _state, eoInit<EO
eoValueParam<double> & epsilonParam = _parser.createParam(0.01, "epsilon", "Half-size of interval for Uniform Mutation", 'e', "Genetic Operators" ); eoValueParam<double> & epsilonParam = _parser.createParam(0.01, "epsilon", "Half-size of interval for Uniform Mutation", 'e', "Genetic Operators" );
// minimum check // minimum check
if ( (epsilonParam.value() < 0) ) if ( (epsilonParam.value() < 0) )
throw runtime_error("Invalid epsilon"); throw std::runtime_error("Invalid epsilon");
eoValueParam<double> & uniformMutRateParam = _parser.createParam(1.0, "uniformMutRate", "Relative rate for uniform mutation", 'u', "Genetic Operators" ); eoValueParam<double> & uniformMutRateParam = _parser.createParam(1.0, "uniformMutRate", "Relative rate for uniform mutation", 'u', "Genetic Operators" );
// minimum check // minimum check
if ( (uniformMutRateParam.value() < 0) ) if ( (uniformMutRateParam.value() < 0) )
throw runtime_error("Invalid uniformMutRate"); throw std::runtime_error("Invalid uniformMutRate");
eoValueParam<double> & detMutRateParam = _parser.createParam(1.0, "detMutRate", "Relative rate for deterministic uniform mutation", 'd', "Genetic Operators" ); eoValueParam<double> & detMutRateParam = _parser.createParam(1.0, "detMutRate", "Relative rate for deterministic uniform mutation", 'd', "Genetic Operators" );
// minimum check // minimum check
if ( (detMutRateParam.value() < 0) ) if ( (detMutRateParam.value() < 0) )
throw runtime_error("Invalid detMutRate"); throw std::runtime_error("Invalid detMutRate");
eoValueParam<double> & normalMutRateParam = _parser.createParam(1.0, "normalMutRate", "Relative rate for Gaussian mutation", 'd', "Genetic Operators" ); eoValueParam<double> & normalMutRateParam = _parser.createParam(1.0, "normalMutRate", "Relative rate for Gaussian mutation", 'd', "Genetic Operators" );
// minimum check // minimum check
if ( (normalMutRateParam.value() < 0) ) if ( (normalMutRateParam.value() < 0) )
throw runtime_error("Invalid normalMutRate"); throw std::runtime_error("Invalid normalMutRate");
// and the sigma // and the sigma
eoValueParam<double> & sigmaParam = _parser.createParam(1.0, "sigma", "Sigma (fixed) for Gaussian mutation", 'S', "Genetic Operators" ); eoValueParam<double> & sigmaParam = _parser.createParam(1.0, "sigma", "Sigma (fixed) for Gaussian mutation", 'S', "Genetic Operators" );
// minimum check // minimum check
if ( (sigmaParam.value() < 0) ) if ( (sigmaParam.value() < 0) )
throw runtime_error("Invalid sigma"); throw std::runtime_error("Invalid sigma");
// minimum check // minimum check
bool bMut = true; bool bMut = true;
if (uniformMutRateParam.value()+detMutRateParam.value()+normalMutRateParam.value()==0) if (uniformMutRateParam.value()+detMutRateParam.value()+normalMutRateParam.value()==0)
{ {
cerr << "Warning: no mutation" << endl; std::cerr << "Warning: no mutation" << std::endl;
bMut = false; bMut = false;
} }
if (!bCross && !bMut) if (!bCross && !bMut)
throw runtime_error("No operator called in SGA operator definition!!!"); throw std::runtime_error("No operator called in SGA operator definition!!!");
// Create the CombinedMonOp // Create the CombinedMonOp
eoPropCombinedMonOp<EOT> *ptCombinedMonOp = NULL; eoPropCombinedMonOp<EOT> *ptCombinedMonOp = NULL;

40
eo/src/es/make_op_es.h
View file

@ -70,17 +70,17 @@
template <class EOT> template <class EOT>
eoGenOp<EOT> & do_make_op(eoParser& _parser, eoState& _state, eoRealInitBounded<EOT>& _init) eoGenOp<EOT> & do_make_op(eoParser& _parser, eoState& _state, eoRealInitBounded<EOT>& _init)
{ {
// get vector size // get std::vector size
unsigned vecSize = _init.size(); unsigned vecSize = _init.size();
// First, decide whether the objective variables are bounded // First, decide whether the objective variables are bounded
eoValueParam<eoRealVectorBounds>& boundsParam = _parser.createParam(eoRealVectorBounds(vecSize,eoDummyRealNoBounds), "objectBounds", "Bounds for variables", 'B', "Variation Operators"); eoValueParam<eoRealVectorBounds>& boundsParam = _parser.createParam(eoRealVectorBounds(vecSize,eoDummyRealNoBounds), "objectBounds", "Bounds for variables", 'B', "Variation Operators");
// now we read Pcross and Pmut, // now we read Pcross and Pmut,
eoValueParam<string>& operatorParam = _parser.createParam(string("SGA"), "operator", "Description of the operator (SGA only now)", 'o', "Variation Operators"); eoValueParam<std::string>& operatorParam = _parser.createParam(std::string("SGA"), "operator", "Description of the operator (SGA only now)", 'o', "Variation Operators");
if (operatorParam.value() != string("SGA")) if (operatorParam.value() != std::string("SGA"))
throw runtime_error("Sorry, only SGA-like operator available right now\n"); throw std::runtime_error("Sorry, only SGA-like operator available right now\n");
// now we read Pcross and Pmut, // now we read Pcross and Pmut,
// and create the eoGenOp that is exactly // and create the eoGenOp that is exactly
@ -89,21 +89,21 @@ eoGenOp<EOT> & do_make_op(eoParser& _parser, eoState& _state, eoRealInitBounded<
eoValueParam<double>& pCrossParam = _parser.createParam(1.0, "pCross", "Probability of Crossover", 'C', "Variation Operators" ); eoValueParam<double>& pCrossParam = _parser.createParam(1.0, "pCross", "Probability of Crossover", 'C', "Variation Operators" );
// minimum check // minimum check
if ( (pCrossParam.value() < 0) || (pCrossParam.value() > 1) ) if ( (pCrossParam.value() < 0) || (pCrossParam.value() > 1) )
throw runtime_error("Invalid pCross"); throw std::runtime_error("Invalid pCross");
eoValueParam<double>& pMutParam = _parser.createParam(1.0, "pMut", "Probability of Mutation", 'M', "Variation Operators" ); eoValueParam<double>& pMutParam = _parser.createParam(1.0, "pMut", "Probability of Mutation", 'M', "Variation Operators" );
// minimum check // minimum check
if ( (pMutParam.value() < 0) || (pMutParam.value() > 1) ) if ( (pMutParam.value() < 0) || (pMutParam.value() > 1) )
throw runtime_error("Invalid pMut"); throw std::runtime_error("Invalid pMut");
// crossover // crossover
///////////// /////////////
// ES crossover // ES crossover
eoValueParam<string>& crossTypeParam = _parser.createParam(string("global"), "crossType", "Type of ES recombination (global or standard)", 'C', "Variation Operators"); eoValueParam<std::string>& crossTypeParam = _parser.createParam(std::string("global"), "crossType", "Type of ES recombination (global or standard)", 'C', "Variation Operators");
eoValueParam<string>& crossObjParam = _parser.createParam(string("discrete"), "crossObj", "Recombination of object variables (discrete, intermediate or none)", 'O', "Variation Operators"); eoValueParam<std::string>& crossObjParam = _parser.createParam(std::string("discrete"), "crossObj", "Recombination of object variables (discrete, intermediate or none)", 'O', "Variation Operators");
eoValueParam<string>& crossStdevParam = _parser.createParam(string("intermediate"), "crossStdev", "Recombination of mutation strategy parameters (intermediate, discrete or none)", 'S', "Variation Operators"); eoValueParam<std::string>& crossStdevParam = _parser.createParam(std::string("intermediate"), "crossStdev", "Recombination of mutation strategy parameters (intermediate, discrete or none)", 'S', "Variation Operators");
// The pointers: first the atom Xover // The pointers: first the atom Xover
eoBinOp<double> *ptObjAtomCross = NULL; eoBinOp<double> *ptObjAtomCross = NULL;
@ -112,33 +112,33 @@ eoGenOp<EOT> & do_make_op(eoParser& _parser, eoState& _state, eoRealInitBounded<
eoGenOp<EOT> *ptCross; eoGenOp<EOT> *ptCross;
// check for the atom Xovers // check for the atom Xovers
if (crossObjParam.value() == string("discrete")) if (crossObjParam.value() == std::string("discrete"))
ptObjAtomCross = new eoDoubleExchange; ptObjAtomCross = new eoDoubleExchange;
else if (crossObjParam.value() == string("intermediate")) else if (crossObjParam.value() == std::string("intermediate"))
ptObjAtomCross = new eoDoubleIntermediate; ptObjAtomCross = new eoDoubleIntermediate;
else if (crossObjParam.value() == string("none")) else if (crossObjParam.value() == std::string("none"))
ptObjAtomCross = new eoBinCloneOp<double>; ptObjAtomCross = new eoBinCloneOp<double>;
else throw runtime_error("Invalid Object variable crossover type"); else throw std::runtime_error("Invalid Object variable crossover type");
if (crossStdevParam.value() == string("discrete")) if (crossStdevParam.value() == std::string("discrete"))
ptStdevAtomCross = new eoDoubleExchange; ptStdevAtomCross = new eoDoubleExchange;
else if (crossStdevParam.value() == string("intermediate")) else if (crossStdevParam.value() == std::string("intermediate"))
ptStdevAtomCross = new eoDoubleIntermediate; ptStdevAtomCross = new eoDoubleIntermediate;
else if (crossStdevParam.value() == string("none")) else if (crossStdevParam.value() == std::string("none"))
ptStdevAtomCross = new eoBinCloneOp<double>; ptStdevAtomCross = new eoBinCloneOp<double>;
else throw runtime_error("Invalid mutation strategy parameter crossover type"); else throw std::runtime_error("Invalid mutation strategy parameter crossover type");
// and build the indi Xover // and build the indi Xover
if (crossTypeParam.value() == string("global")) if (crossTypeParam.value() == std::string("global"))
ptCross = new eoEsGlobalXover<EOT>(*ptObjAtomCross, *ptStdevAtomCross); ptCross = new eoEsGlobalXover<EOT>(*ptObjAtomCross, *ptStdevAtomCross);
else if (crossTypeParam.value() == string("standard")) else if (crossTypeParam.value() == std::string("standard"))
{ // using a standard eoBinOp, but wrap it into an eoGenOp { // using a standard eoBinOp, but wrap it into an eoGenOp
eoBinOp<EOT> & crossTmp = _state.storeFunctor( eoBinOp<EOT> & crossTmp = _state.storeFunctor(
new eoEsStandardXover<EOT>(*ptObjAtomCross, *ptStdevAtomCross) new eoEsStandardXover<EOT>(*ptObjAtomCross, *ptStdevAtomCross)
); );
ptCross = new eoBinGenOp<EOT>(crossTmp); ptCross = new eoBinGenOp<EOT>(crossTmp);
} }
else throw runtime_error("Invalide Object variable crossover type"); else throw std::runtime_error("Invalide Object variable crossover type");
// now that everything is OK, DON'T FORGET TO STORE MEMORY // now that everything is OK, DON'T FORGET TO STORE MEMORY
_state.storeFunctor(ptObjAtomCross); _state.storeFunctor(ptObjAtomCross);

34
eo/src/es/make_op_real.h
View file

@ -67,7 +67,7 @@
template <class EOT> template <class EOT>
eoGenOp<EOT> & do_make_op(eoParser& _parser, eoState& _state, eoRealInitBounded<EOT>& _init) eoGenOp<EOT> & do_make_op(eoParser& _parser, eoState& _state, eoRealInitBounded<EOT>& _init)
{ {
// get vector size // get std::vector size
unsigned vecSize = _init.size(); unsigned vecSize = _init.size();
// First, decide whether the objective variables are bounded // First, decide whether the objective variables are bounded
@ -77,10 +77,10 @@ eoGenOp<EOT> & do_make_op(eoParser& _parser, eoState& _state, eoRealInitBounded<
// while Maarten codes the full tree-structured general operator input // while Maarten codes the full tree-structured general operator input
// BTW we must leave that simple version available somehow, as it is the one // BTW we must leave that simple version available somehow, as it is the one
// that 90% people use! // that 90% people use!
eoValueParam<string>& operatorParam = _parser.createParam(string("SGA"), "operator", "Description of the operator (SGA only now)", 'o', "Variation Operators"); eoValueParam<std::string>& operatorParam = _parser.createParam(std::string("SGA"), "operator", "Description of the operator (SGA only now)", 'o', "Variation Operators");
if (operatorParam.value() != string("SGA")) if (operatorParam.value() != std::string("SGA"))
throw runtime_error("Sorry, only SGA-like operator available right now\n"); throw std::runtime_error("Sorry, only SGA-like operator available right now\n");
// now we read Pcross and Pmut, // now we read Pcross and Pmut,
// the relative weights for all crossovers -> proportional choice // the relative weights for all crossovers -> proportional choice
@ -91,12 +91,12 @@ eoGenOp<EOT> & do_make_op(eoParser& _parser, eoState& _state, eoRealInitBounded<
eoValueParam<double>& pCrossParam = _parser.createParam(0.6, "pCross", "Probability of Crossover", 'C', "Variation Operators" ); eoValueParam<double>& pCrossParam = _parser.createParam(0.6, "pCross", "Probability of Crossover", 'C', "Variation Operators" );
// minimum check // minimum check
if ( (pCrossParam.value() < 0) || (pCrossParam.value() > 1) ) if ( (pCrossParam.value() < 0) || (pCrossParam.value() > 1) )
throw runtime_error("Invalid pCross"); throw std::runtime_error("Invalid pCross");
eoValueParam<double>& pMutParam = _parser.createParam(0.1, "pMut", "Probability of Mutation", 'M', "Variation Operators" ); eoValueParam<double>& pMutParam = _parser.createParam(0.1, "pMut", "Probability of Mutation", 'M', "Variation Operators" );
// minimum check // minimum check
if ( (pMutParam.value() < 0) || (pMutParam.value() > 1) ) if ( (pMutParam.value() < 0) || (pMutParam.value() > 1) )
throw runtime_error("Invalid pMut"); throw std::runtime_error("Invalid pMut");
// the crossovers // the crossovers
///////////////// /////////////////
@ -104,29 +104,29 @@ eoGenOp<EOT> & do_make_op(eoParser& _parser, eoState& _state, eoRealInitBounded<
eoValueParam<double>& alphaParam = _parser.createParam(double(0.0), "alpha", "Bound for factor of linear recombinations", 'a', "Variation Operators" ); eoValueParam<double>& alphaParam = _parser.createParam(double(0.0), "alpha", "Bound for factor of linear recombinations", 'a', "Variation Operators" );
// minimum check // minimum check
if ( (alphaParam.value() < 0) ) if ( (alphaParam.value() < 0) )
throw runtime_error("Invalid BLX coefficient alpha"); throw std::runtime_error("Invalid BLX coefficient alpha");
eoValueParam<double>& segmentRateParam = _parser.createParam(double(1.0), "segmentRate", "Relative rate for segment crossover", 's', "Variation Operators" ); eoValueParam<double>& segmentRateParam = _parser.createParam(double(1.0), "segmentRate", "Relative rate for segment crossover", 's', "Variation Operators" );
// minimum check // minimum check
if ( (segmentRateParam.value() < 0) ) if ( (segmentRateParam.value() < 0) )
throw runtime_error("Invalid segmentRate"); throw std::runtime_error("Invalid segmentRate");
eoValueParam<double>& hypercubeRateParam = _parser.createParam(double(1.0), "hypercubeRate", "Relative rate for hypercube crossover", 'A', "Variation Operators" ); eoValueParam<double>& hypercubeRateParam = _parser.createParam(double(1.0), "hypercubeRate", "Relative rate for hypercube crossover", 'A', "Variation Operators" );
// minimum check // minimum check
if ( (hypercubeRateParam.value() < 0) ) if ( (hypercubeRateParam.value() < 0) )
throw runtime_error("Invalid hypercubeRate"); throw std::runtime_error("Invalid hypercubeRate");
eoValueParam<double>& uxoverRateParam = _parser.createParam(double(1.0), "uxoverRate", "Relative rate for uniform crossover", 'A', "Variation Operators" ); eoValueParam<double>& uxoverRateParam = _parser.createParam(double(1.0), "uxoverRate", "Relative rate for uniform crossover", 'A', "Variation Operators" );
// minimum check // minimum check
if ( (uxoverRateParam.value() < 0) ) if ( (uxoverRateParam.value() < 0) )
throw runtime_error("Invalid uxoverRate"); throw std::runtime_error("Invalid uxoverRate");
// minimum check // minimum check
bool bCross = true; bool bCross = true;
if (segmentRateParam.value()+hypercubeRateParam.value()+uxoverRateParam.value()==0) if (segmentRateParam.value()+hypercubeRateParam.value()+uxoverRateParam.value()==0)
{ {
cerr << "Warning: no crossover" << endl; std::cerr << "Warning: no crossover" << std::endl;
bCross = false; bCross = false;
} }
@ -161,22 +161,22 @@ eoGenOp<EOT> & do_make_op(eoParser& _parser, eoState& _state, eoRealInitBounded<
eoValueParam<double> & epsilonParam = _parser.createParam(0.01, "epsilon", "Half-size of interval for Uniform Mutation", 'e', "Variation Operators" ); eoValueParam<double> & epsilonParam = _parser.createParam(0.01, "epsilon", "Half-size of interval for Uniform Mutation", 'e', "Variation Operators" );
// minimum check // minimum check
if ( (epsilonParam.value() < 0) ) if ( (epsilonParam.value() < 0) )
throw runtime_error("Invalid epsilon"); throw std::runtime_error("Invalid epsilon");
eoValueParam<double> & uniformMutRateParam = _parser.createParam(1.0, "uniformMutRate", "Relative rate for uniform mutation", 'u', "Variation Operators" ); eoValueParam<double> & uniformMutRateParam = _parser.createParam(1.0, "uniformMutRate", "Relative rate for uniform mutation", 'u', "Variation Operators" );
// minimum check // minimum check
if ( (uniformMutRateParam.value() < 0) ) if ( (uniformMutRateParam.value() < 0) )
throw runtime_error("Invalid uniformMutRate"); throw std::runtime_error("Invalid uniformMutRate");
eoValueParam<double> & detMutRateParam = _parser.createParam(1.0, "detMutRate", "Relative rate for deterministic uniform mutation", 'd', "Variation Operators" ); eoValueParam<double> & detMutRateParam = _parser.createParam(1.0, "detMutRate", "Relative rate for deterministic uniform mutation", 'd', "Variation Operators" );
// minimum check // minimum check
if ( (detMutRateParam.value() < 0) ) if ( (detMutRateParam.value() < 0) )
throw runtime_error("Invalid detMutRate"); throw std::runtime_error("Invalid detMutRate");
eoValueParam<double> & normalMutRateParam = _parser.createParam(1.0, "normalMutRate", "Relative rate for Gaussian mutation", 'd', "Variation Operators" ); eoValueParam<double> & normalMutRateParam = _parser.createParam(1.0, "normalMutRate", "Relative rate for Gaussian mutation", 'd', "Variation Operators" );
// minimum check // minimum check
if ( (normalMutRateParam.value() < 0) ) if ( (normalMutRateParam.value() < 0) )
throw runtime_error("Invalid normalMutRate"); throw std::runtime_error("Invalid normalMutRate");
eoValueParam<double> & sigmaParam = _parser.createParam(0.3, "sigma", "Sigma (fixed) for Gaussian mutation", 's', "Variation Operators" ); eoValueParam<double> & sigmaParam = _parser.createParam(0.3, "sigma", "Sigma (fixed) for Gaussian mutation", 's', "Variation Operators" );
@ -184,11 +184,11 @@ eoGenOp<EOT> & do_make_op(eoParser& _parser, eoState& _state, eoRealInitBounded<
bool bMut = true; bool bMut = true;
if (uniformMutRateParam.value()+detMutRateParam.value()+normalMutRateParam.value()==0) if (uniformMutRateParam.value()+detMutRateParam.value()+normalMutRateParam.value()==0)
{ {
cerr << "Warning: no mutation" << endl; std::cerr << "Warning: no mutation" << std::endl;
bMut = false; bMut = false;
} }
if (!bCross && !bMut) if (!bCross && !bMut)
throw runtime_error("No operator called in SGA operator definition!!!"); throw std::runtime_error("No operator called in SGA operator definition!!!");
// Create the CombinedMonOp // Create the CombinedMonOp
eoPropCombinedMonOp<EOT> *ptCombinedMonOp = NULL; eoPropCombinedMonOp<EOT> *ptCombinedMonOp = NULL;

2
eo/src/es/make_real.h
View file

@ -25,7 +25,7 @@
//----------------------------------------------------------------------------- //-----------------------------------------------------------------------------
/** This file contains all ***INSTANCIATED*** declarations of all components /** This file contains all ***INSTANCIATED*** declarations of all components
* of the library for ***vector<RealValues>*** evolution inside EO. * of the library for ***std::vector<RealValues>*** evolution inside EO.
* It should be included in the file that calls any of the corresponding fns * It should be included in the file that calls any of the corresponding fns
* *
* The corresponding ***INSTANCIATED*** definitions are contained in * The corresponding ***INSTANCIATED*** definitions are contained in

26
eo/src/ga/eoBit.h
View file

@ -35,9 +35,9 @@
//----------------------------------------------------------------------------- //-----------------------------------------------------------------------------
#include <iostream> // ostream, istream #include <iostream> // std::ostream, std::istream
#include <functional> // bind2nd #include <functional> // bind2nd
#include <string> // string #include <string> // std::string
#include <eoVector.h> #include <eoVector.h>
@ -50,7 +50,7 @@
/** eoBit: implementation of bitstring chromosome. /** eoBit: implementation of bitstring chromosome.
\class eoBit eoBit.h ga/eoBit.h \class eoBit eoBit.h ga/eoBit.h
\ingroup bitstring \ingroup bitstring
* based on STL's vector<bool> specialization. * based on STL's std::vector<bool> specialization.
*/ */
template <class FitT> class eoBit: public eoVector<FitT, bool> template <class FitT> class eoBit: public eoVector<FitT, bool>
{ {
@ -58,45 +58,45 @@ template <class FitT> class eoBit: public eoVector<FitT, bool>
/** /**
* (Default) Constructor. * (Default) Constructor.
* @param size Size of the binary string. * @param size Size of the binary std::string.
*/ */
eoBit(unsigned size = 0, bool value = false): eoBit(unsigned size = 0, bool value = false):
eoVector<FitT, bool>(size, value) {} eoVector<FitT, bool>(size, value) {}
/// My class name. /// My class name.
virtual string className() const virtual std::string className() const
{ {
return "eoBit"; return "eoBit";
} }
/** /**
* To print me on a stream. * To print me on a stream.
* @param os The ostream. * @param os The std::ostream.
*/ */
virtual void printOn(ostream& os) const virtual void printOn(std::ostream& os) const
{ {
EO<FitT>::printOn(os); EO<FitT>::printOn(os);
os << ' '; os << ' ';
os << size() << ' '; os << size() << ' ';
copy(begin(), end(), ostream_iterator<bool>(os)); std::copy(begin(), end(), std::ostream_iterator<bool>(os));
} }
/** /**
* To read me from a stream. * To read me from a stream.
* @param is The istream. * @param is The std::istream.
*/ */
virtual void readFrom(istream& is) virtual void readFrom(std::istream& is)
{ {
EO<FitT>::readFrom(is); EO<FitT>::readFrom(is);
unsigned s; unsigned s;
is >> s; is >> s;
string bits; std::string bits;
is >> bits; is >> bits;
if (is) if (is)
{ {
resize(bits.size()); resize(bits.size());
transform(bits.begin(), bits.end(), begin(), std::transform(bits.begin(), bits.end(), begin(),
bind2nd(equal_to<char>(), '1')); std::bind2nd(std::equal_to<char>(), '1'));
} }
} }
}; };

66
eo/src/ga/eoBitOp.h
View file

@ -21,7 +21,7 @@
Contact: todos@geneura.ugr.es, http://geneura.ugr.es Contact: todos@geneura.ugr.es, http://geneura.ugr.es
Marc.Schoenauer@polytechnique.fr Marc.Schoenauer@polytechnique.fr
mak@dhi.dk mak@dhi.dk
CVS Info: $Date: 2001-09-08 05:59:17 $ $Header: /home/nojhan/dev/eodev/eodev_cvs/eo/src/ga/eoBitOp.h,v 1.14 2001-09-08 05:59:17 evomarc Exp $ $Author: evomarc $ CVS Info: $Date: 2003-02-27 19:24:47 $ $Header: /home/nojhan/dev/eodev/eodev_cvs/eo/src/ga/eoBitOp.h,v 1.15 2003-02-27 19:24:47 okoenig Exp $ $Author: okoenig $
*/ */
//----------------------------------------------------------------------------- //-----------------------------------------------------------------------------
@ -45,7 +45,7 @@ template<class Chrom> class eoOneBitFlip: public eoMonOp<Chrom>
{ {
public: public:
/// The class name. /// The class name.
virtual string className() const { return "eoOneBitFlip"; } virtual std::string className() const { return "eoOneBitFlip"; }
/** /**
* Change one bit. * Change one bit.
@ -75,7 +75,7 @@ template<class Chrom> class eoDetBitFlip: public eoMonOp<Chrom>
eoDetBitFlip(const unsigned& _num_bit = 1): num_bit(_num_bit) {} eoDetBitFlip(const unsigned& _num_bit = 1): num_bit(_num_bit) {}
/// The class name. /// The class name.
virtual string className() const { return "eoDetBitFlip"; } virtual std::string className() const { return "eoDetBitFlip"; }
/** /**
* Change num_bit bits. * Change num_bit bits.
@ -112,7 +112,7 @@ template<class Chrom> class eoBitMutation: public eoMonOp<Chrom>
rate(_rate), normalize(_normalize) {} rate(_rate), normalize(_normalize) {}
/// The class name. /// The class name.
virtual string className() const { return "eoBitMutation"; } virtual std::string className() const { return "eoBitMutation"; }
/** /**
* Mutate a chromosome. * Mutate a chromosome.
@ -147,7 +147,7 @@ template<class Chrom> class eoBitInversion: public eoMonOp<Chrom>
{ {
public: public:
/// The class name. /// The class name.
virtual string className() const { return "eoBitInversion"; } virtual std::string className() const { return "eoBitInversion"; }
/** /**
* Inverts a range of bits in a binary chromosome. * Inverts a range of bits in a binary chromosome.
@ -158,9 +158,9 @@ template<class Chrom> class eoBitInversion: public eoMonOp<Chrom>
unsigned u1 = eo::rng.random(chrom.size() + 1) , u2; unsigned u1 = eo::rng.random(chrom.size() + 1) , u2;
do u2 = eo::rng.random(chrom.size() + 1); while (u1 == u2); do u2 = eo::rng.random(chrom.size() + 1); while (u1 == u2);
unsigned r1 = min(u1, u2), r2 = max(u1, u2); unsigned r1 = std::min(u1, u2), r2 = std::max(u1, u2);
reverse(chrom.begin() + r1, chrom.begin() + r2); std::reverse(chrom.begin() + r1, chrom.begin() + r2);
return true; return true;
} }
}; };
@ -175,10 +175,10 @@ template<class Chrom> class eoBitNext: public eoMonOp<Chrom>
{ {
public: public:
/// The class name. /// The class name.
virtual string className() const { return "eoBitNext"; } virtual std::string className() const { return "eoBitNext"; }
/** /**
* Change the bit string x to be x+1. * Change the bit std::string x to be x+1.
* @param chrom The chromosome to be added one. * @param chrom The chromosome to be added one.
*/ */
bool operator()(Chrom& chrom) bool operator()(Chrom& chrom)
@ -209,10 +209,10 @@ template<class Chrom> class eoBitPrev: public eoMonOp<Chrom>
{ {
public: public:
/// The class name. /// The class name.
virtual string className() const { return "eoBitPrev"; } virtual std::string className() const { return "eoBitPrev"; }
/** /**
* Change the bit string x to be x-1. * Change the bit std::string x to be x-1.
* @param chrom The chromosome to be substracted one. * @param chrom The chromosome to be substracted one.
*/ */
bool operator()(Chrom& chrom) bool operator()(Chrom& chrom)
@ -243,7 +243,7 @@ template<class Chrom> class eo1PtBitXover: public eoQuadOp<Chrom>
{ {
public: public:
/// The class name. /// The class name.
virtual string className() const { return "eo1PtBitXover"; } virtual std::string className() const { return "eo1PtBitXover"; }
/** /**
* 1-point crossover for binary chromosomes. * 1-point crossover for binary chromosomes.
@ -252,12 +252,12 @@ template<class Chrom> class eo1PtBitXover: public eoQuadOp<Chrom>
*/ */
bool operator()(Chrom& chrom1, Chrom& chrom2) bool operator()(Chrom& chrom1, Chrom& chrom2)
{ {
unsigned site = eo::rng.random(min(chrom1.size(), chrom2.size())); unsigned site = eo::rng.random(std::min(chrom1.size(), chrom2.size()));
if (!std::equal(chrom1.begin(), chrom1.begin()+site, chrom2.begin())) if (!std::equal(chrom1.begin(), chrom1.begin()+site, chrom2.begin()))
{ {
swap_ranges(chrom1.begin(), chrom1.begin() + site, chrom2.begin()); std::swap_ranges(chrom1.begin(), chrom1.begin() + site, chrom2.begin());
return true; return true;
} }
@ -278,21 +278,21 @@ template<class Chrom> class eoUBitXover: public eoQuadOp<Chrom>
eoUBitXover(const float& _preference = 0.5): preference(_preference) eoUBitXover(const float& _preference = 0.5): preference(_preference)
{ {
if ( (_preference <= 0.0) || (_preference >= 1.0) ) if ( (_preference <= 0.0) || (_preference >= 1.0) )
runtime_error("UxOver --> invalid preference"); std::runtime_error("UxOver --> invalid preference");
} }
/// The class name. /// The class name.
virtual string className() const { return "eoUBitXover"; } virtual std::string className() const { return "eoUBitXover"; }
/** /**
* Uniform crossover for binary chromosomes. * Uniform crossover for binary chromosomes.
* @param chrom1 The first chromosome. * @param chrom1 The first chromosome.
* @param chrom2 The first chromosome. * @param chrom2 The first chromosome.
* @runtime_error if sizes don't match * @std::runtime_error if sizes don't match
*/ */
bool operator()(Chrom& chrom1, Chrom& chrom2) bool operator()(Chrom& chrom1, Chrom& chrom2)
{ {
if ( chrom1.size() != chrom2.size()) if ( chrom1.size() != chrom2.size())
runtime_error("UxOver --> chromosomes sizes don't match" ); std::runtime_error("UxOver --> chromosomes sizes don't match" );
bool changed = false; bool changed = false;
for (unsigned int i=0; i<chrom1.size(); i++) for (unsigned int i=0; i<chrom1.size(); i++)
{ {
@ -323,11 +323,11 @@ template<class Chrom> class eoNPtsBitXover: public eoQuadOp<Chrom>
eoNPtsBitXover(const unsigned& _num_points = 2): num_points(_num_points) eoNPtsBitXover(const unsigned& _num_points = 2): num_points(_num_points)
{ {
if (num_points < 1) if (num_points < 1)
runtime_error("NxOver --> invalid number of points"); std::runtime_error("NxOver --> invalid number of points");
} }
/// The class name. /// The class name.
virtual string className() const { return "eoNPtsBitXover"; } virtual std::string className() const { return "eoNPtsBitXover"; }
/** /**
* n-point crossover for binary chromosomes. * n-point crossover for binary chromosomes.
@ -336,10 +336,10 @@ template<class Chrom> class eoNPtsBitXover: public eoQuadOp<Chrom>
*/ */
bool operator()(Chrom& chrom1, Chrom& chrom2) bool operator()(Chrom& chrom1, Chrom& chrom2)
{ {
unsigned max_size = min(chrom1.size(), chrom2.size()); unsigned max_size = std::min(chrom1.size(), chrom2.size());
unsigned max_points = min(max_size - 1, num_points); unsigned max_points = std::min(max_size - 1, num_points);
vector<bool> points(max_size, false); std::vector<bool> points(max_size, false);
// select ranges of bits to swap // select ranges of bits to swap
do { do {
@ -362,7 +362,7 @@ template<class Chrom> class eoNPtsBitXover: public eoQuadOp<Chrom>
change = !change; change = !change;
if (change) if (change)
swap(chrom1[bit], chrom2[bit]); std::swap(chrom1[bit], chrom2[bit]);
} }
return true; return true;
@ -374,8 +374,8 @@ template<class Chrom> class eoNPtsBitXover: public eoQuadOp<Chrom>
/** eoBitGxOver --> Npts crossover when bistring considered /** eoBitGxOver --> Npts crossover when bistd::string considered
as a string of binary-encoded genes (exchanges genes) as a std::string of binary-encoded genes (exchanges genes)
Is anybody still using it apart from historians ??? :-) Is anybody still using it apart from historians ??? :-)
\class eoBitGxOver eoBitOp.h ga/eoBitOp.h \class eoBitGxOver eoBitOp.h ga/eoBitOp.h
\ingroup bitstring \ingroup bitstring
@ -389,13 +389,13 @@ template<class Chrom> class eoBitGxOver: public eoQuadOp<Chrom>
gene_size(_gene_size), num_points(_num_points) gene_size(_gene_size), num_points(_num_points)
{ {
if (gene_size < 1) if (gene_size < 1)
runtime_error("GxOver --> invalid gene size"); std::runtime_error("GxOver --> invalid gene size");
if (num_points < 1) if (num_points < 1)
runtime_error("GxOver --> invalid number of points"); std::runtime_error("GxOver --> invalid number of points");
} }
/// The class name /// The class name
virtual string className() const { return "eoBitGxOver"; } virtual std::string className() const { return "eoBitGxOver"; }
/** /**
* Gene crossover for binary chromosomes. * Gene crossover for binary chromosomes.
@ -404,10 +404,10 @@ template<class Chrom> class eoBitGxOver: public eoQuadOp<Chrom>
*/ */
bool operator()(Chrom& chrom1, Chrom& chrom2) bool operator()(Chrom& chrom1, Chrom& chrom2)
{ {
unsigned max_genes = min(chrom1.size(), chrom2.size()) / gene_size; unsigned max_genes = std::min(chrom1.size(), chrom2.size()) / gene_size;
unsigned cut_genes = min(max_genes, num_points); unsigned cut_genes = std::min(max_genes, num_points);
vector<bool> points(max_genes, false); std::vector<bool> points(max_genes, false);
// selects genes to swap // selects genes to swap
do { do {
@ -424,7 +424,7 @@ template<class Chrom> class eoBitGxOver: public eoQuadOp<Chrom>
// swaps genes // swaps genes
for (unsigned i = 0; i < points.size(); i++) for (unsigned i = 0; i < points.size(); i++)
if (points[i]) if (points[i])
swap_ranges(chrom1.begin() + i * gene_size, std::swap_ranges(chrom1.begin() + i * gene_size,
chrom1.begin() + i * gene_size + gene_size, chrom1.begin() + i * gene_size + gene_size,
chrom2.begin() + i * gene_size); chrom2.begin() + i * gene_size);

14
eo/src/ga/eoBitOpFactory.h
View file

@ -50,22 +50,22 @@ public:
virtual ~eoBitOpFactory() {}; virtual ~eoBitOpFactory() {};
//@} //@}
/** Another factory method: creates an object from an istream, reading from /** Another factory method: creates an object from an std::istream, reading from
it whatever is needed to create the object. Usually, the format for the istream will be\\ it whatever is needed to create the object. Usually, the format for the std::istream will be\\
objectType parameter1 parameter2 ... parametern\\ objectType parameter1 parameter2 ... parametern\\
If there are problems, an exception is raised; it should be caught at the If there are problems, an std::exception is raised; it should be caught at the
upper level, because it might be something for that level\\ upper level, because it might be something for that level\\
At the same time, it catches exceptions thrown at a lower level, which will At the same time, it catches std::exceptions thrown at a lower level, which will
indicate that whatever is in the stream is for this method to process indicate that whatever is in the stream is for this method to process
@param _is an stream from where a single line will be read @param _is an stream from where a single line will be read
@throw runtime_exception if the object type is not known @throw runtime_std::exception if the object type is not known
*/ */
virtual eoOp<EOT>* make(istream& _is) virtual eoOp<EOT>* make(std::istream& _is)
{ {
eoOp<EOT> * opPtr = NULL; eoOp<EOT> * opPtr = NULL;
try { try {
opPtr = eoFactory<EOT>::make( _is ); opPtr = eoFactory<EOT>::make( _is );
} catch ( const string& objectTypeStr ) { } catch ( const std::string& objectTypeStr ) {
if ( objectTypeStr == "eoBinBitFlip" ) { if ( objectTypeStr == "eoBinBitFlip" ) {
opPtr = new eoOneBitFlip<EOT>( ); opPtr = new eoOneBitFlip<EOT>( );
} }

6
eo/src/ga/eoPBILAdditive.h
View file

@ -56,7 +56,7 @@ public:
LR(0.0), nbBest(_nbBest), nbWorst(_nbWorst) LR(0.0), nbBest(_nbBest), nbWorst(_nbWorst)
{ {
if (nbBest+nbWorst == 0) if (nbBest+nbWorst == 0)
throw runtime_error("Must update either from best or from worst in eoPBILAdditive"); throw std::runtime_error("Must update either from best or from worst in eoPBILAdditive");
if (_nbBest) if (_nbBest)
{ {
@ -79,10 +79,10 @@ public:
{ {
eoPBILDistrib<EOT>& distrib = dynamic_cast<eoPBILDistrib<EOT>&>(_distrib); eoPBILDistrib<EOT>& distrib = dynamic_cast<eoPBILDistrib<EOT>&>(_distrib);
vector<double> & p = distrib.value(); std::vector<double> & p = distrib.value();
unsigned i, popSize=_pop.size(); unsigned i, popSize=_pop.size();
vector<const EOT*> result; std::vector<const EOT*> result;
_pop.sort(result); // is it necessary to sort the whole population? _pop.sort(result); // is it necessary to sort the whole population?
// but I'm soooooooo lazy !!! // but I'm soooooooo lazy !!!

14
eo/src/ga/eoPBILDistrib.h
View file

@ -34,21 +34,21 @@
* It encodes a univariate distribution on the space of bitstrings, * It encodes a univariate distribution on the space of bitstrings,
* i.e. one probability for each bit to be one * i.e. one probability for each bit to be one
* *
* It is an eoValueParam<vector<double> > : * It is an eoValueParam<std::vector<double> > :
* the vector<double> stores the probabilities that each bit is 1 * the std::vector<double> stores the probabilities that each bit is 1
* *
* It is still pure virtual, as the update method needs to be specified * It is still pure virtual, as the update method needs to be specified
*/ */
template <class EOT> template <class EOT>
class eoPBILDistrib : public eoDistribution<EOT>, class eoPBILDistrib : public eoDistribution<EOT>,
public eoValueParam<vector<double> > public eoValueParam<std::vector<double> >
{ {
public: public:
/** Ctor with size of genomes, and update parameters */ /** Ctor with size of genomes, and update parameters */
eoPBILDistrib(unsigned _genomeSize) : eoPBILDistrib(unsigned _genomeSize) :
eoDistribution<EOT>(), eoDistribution<EOT>(),
eoValueParam<vector<double> >(vector<double>(_genomeSize, 0.5), "Distribution"), eoValueParam<std::vector<double> >(std::vector<double>(_genomeSize, 0.5), "Distribution"),
genomeSize(_genomeSize) genomeSize(_genomeSize)
{} {}
@ -65,7 +65,7 @@ public:
unsigned Size() {return genomeSize;} unsigned Size() {return genomeSize;}
/** printing... */ /** printing... */
virtual void printOn(ostream& os) const virtual void printOn(std::ostream& os) const
{ {
os << value().size() << ' '; os << value().size() << ' ';
for (unsigned i=0; i<value().size(); i++) for (unsigned i=0; i<value().size(); i++)
@ -73,7 +73,7 @@ public:
} }
/** reading...*/ /** reading...*/
virtual void readFrom(istream& is) virtual void readFrom(std::istream& is)
{ {
unsigned sz; unsigned sz;
is >> sz; is >> sz;
@ -91,7 +91,7 @@ public:
unsigned int size() {return genomeSize;} unsigned int size() {return genomeSize;}
virtual string className() const {return "eoPBILDistrib";}; virtual std::string className() const {return "eoPBILDistrib";};
private: private:
unsigned genomeSize; // size of indis unsigned genomeSize; // size of indis

2
eo/src/ga/eoPBILOrg.h
View file

@ -54,7 +54,7 @@ public:
const EOT & best = _pop.best_element(); const EOT & best = _pop.best_element();
eoPBILDistrib<EOT>& distrib = dynamic_cast<eoPBILDistrib<EOT>&>(_distrib); eoPBILDistrib<EOT>& distrib = dynamic_cast<eoPBILDistrib<EOT>&>(_distrib);
vector<double> & p = distrib.value(); std::vector<double> & p = distrib.value();
for (unsigned g=0; g<distrib.size(); g++) for (unsigned g=0; g<distrib.size(); g++)
{ {

4
eo/src/ga/make_PBILdistrib.h
View file

@ -56,7 +56,7 @@ eoPBILDistrib<EOT> & do_make_PBILdistrib(eoParser & _parser, eoState& _state, E
// chromosome size: // chromosome size:
unsigned theSize; unsigned theSize;
// but it might have been already read in the definition fo the performance // but it might have been already read in the definition fo the performance
eoParam* ptParam = _parser.getParamWithLongName(string("chromSize")); eoParam* ptParam = _parser.getParamWithLongName(std::string("chromSize"));
if (!ptParam) // not already defined: read it here if (!ptParam) // not already defined: read it here
{ {
@ -72,7 +72,7 @@ eoPBILDistrib<EOT> & do_make_PBILdistrib(eoParser & _parser, eoState& _state, E
_state.storeFunctor(ptDistrib); _state.storeFunctor(ptDistrib);
// now the initialization: read a previously saved distribution, or random // now the initialization: read a previously saved distribution, or random
eoValueParam<string>& loadNameParam = _parser.createParam(string(""), "Load","A save file to restart from",'L', "Persistence" ); eoValueParam<std::string>& loadNameParam = _parser.createParam(std::string(""), "Load","A save file to restart from",'L', "Persistence" );
if (loadNameParam.value() != "") // something to load if (loadNameParam.value() != "") // something to load
{ {
// create another state for reading // create another state for reading

6
eo/src/ga/make_PBILupdate.h
View file

@ -50,7 +50,7 @@ eoDistribUpdater<EOT> & do_make_PBILupdate(eoParser & _parser, eoState& _state,
// ast the moment, a single update rule is available // ast the moment, a single update rule is available
// but at some point we'll have to choose among different rules // but at some point we'll have to choose among different rules
string UType = _parser.createParam(string("PBIL"), "updateRule", "Type of update rule (only PBIL additive at the moment)", 'U', "Algorithm").value(); std::string UType = _parser.createParam(std::string("PBIL"), "updateRule", "Type of update rule (only PBIL additive at the moment)", 'U', "Algorithm").value();
unsigned nbBest = _parser.createParam(unsigned(1), "nbBest", "Number of good guys to update from", 'B', "Algorithm").value(); unsigned nbBest = _parser.createParam(unsigned(1), "nbBest", "Number of good guys to update from", 'B', "Algorithm").value();
double LRBest = _parser.createParam(0.1, "LRBest", "Learning Rate (from best guys)", 'L', "Algorithm").value(); double LRBest = _parser.createParam(0.1, "LRBest", "Learning Rate (from best guys)", 'L', "Algorithm").value();
@ -61,7 +61,7 @@ eoDistribUpdater<EOT> & do_make_PBILupdate(eoParser & _parser, eoState& _state,
// a pointer to choose among several possible types // a pointer to choose among several possible types
eoDistribUpdater<EOT> * ptUpdate; eoDistribUpdater<EOT> * ptUpdate;
if (UType == string("PBIL")) if (UType == std::string("PBIL"))
{ {
if ( (nbWorst == 0) && (nbBest == 1) ) if ( (nbWorst == 0) && (nbBest == 1) )
ptUpdate = new eoPBILOrg<EOT>(LRBest, tolerance); ptUpdate = new eoPBILOrg<EOT>(LRBest, tolerance);
@ -69,7 +69,7 @@ eoDistribUpdater<EOT> & do_make_PBILupdate(eoParser & _parser, eoState& _state,
ptUpdate = new eoPBILAdditive<EOT>(LRBest, nbBest, tolerance, LRWorst, nbWorst); ptUpdate = new eoPBILAdditive<EOT>(LRBest, nbBest, tolerance, LRWorst, nbWorst);
} }
else else
throw runtime_error("Only PBIL additive update rule available at the moment"); throw std::runtime_error("Only PBIL additive update rule available at the moment");
// done: don't forget to store the allocated pointers // done: don't forget to store the allocated pointers
_state.storeFunctor(ptUpdate); _state.storeFunctor(ptUpdate);

26
eo/src/ga/make_op.h
View file

@ -72,10 +72,10 @@ eoGenOp<EOT> & do_make_op(eoParser& _parser, eoState& _state, eoInit<EOT>& _init
// general operator input // general operator input
// BTW we must leave that simple version available somehow, as it is the one // BTW we must leave that simple version available somehow, as it is the one
// that 90% people use! // that 90% people use!
eoValueParam<string>& operatorParam = _parser.createParam(string("SGA"), "operator", "Description of the operator (SGA only now)", 'o', "Variation Operators"); eoValueParam<std::string>& operatorParam = _parser.createParam(std::string("SGA"), "operator", "Description of the operator (SGA only now)", 'o', "Variation Operators");
if (operatorParam.value() != string("SGA")) if (operatorParam.value() != std::string("SGA"))
throw runtime_error("Only SGA-like operator available right now\n"); throw std::runtime_error("Only SGA-like operator available right now\n");
// now we read Pcross and Pmut, // now we read Pcross and Pmut,
// the relative weights for all crossovers -> proportional choice // the relative weights for all crossovers -> proportional choice
@ -86,12 +86,12 @@ eoGenOp<EOT> & do_make_op(eoParser& _parser, eoState& _state, eoInit<EOT>& _init
eoValueParam<double>& pCrossParam = _parser.createParam(0.6, "pCross", "Probability of Crossover", 'C', "Variation Operators" ); eoValueParam<double>& pCrossParam = _parser.createParam(0.6, "pCross", "Probability of Crossover", 'C', "Variation Operators" );
// minimum check // minimum check
if ( (pCrossParam.value() < 0) || (pCrossParam.value() > 1) ) if ( (pCrossParam.value() < 0) || (pCrossParam.value() > 1) )
throw runtime_error("Invalid pCross"); throw std::runtime_error("Invalid pCross");
eoValueParam<double>& pMutParam = _parser.createParam(0.1, "pMut", "Probability of Mutation", 'M', "Variation Operators" ); eoValueParam<double>& pMutParam = _parser.createParam(0.1, "pMut", "Probability of Mutation", 'M', "Variation Operators" );
// minimum check // minimum check
if ( (pMutParam.value() < 0) || (pMutParam.value() > 1) ) if ( (pMutParam.value() < 0) || (pMutParam.value() > 1) )
throw runtime_error("Invalid pMut"); throw std::runtime_error("Invalid pMut");
// the crossovers // the crossovers
///////////////// /////////////////
@ -99,23 +99,23 @@ eoGenOp<EOT> & do_make_op(eoParser& _parser, eoState& _state, eoInit<EOT>& _init
eoValueParam<double>& onePointRateParam = _parser.createParam(double(1.0), "onePointRate", "Relative rate for one point crossover", '1', "Variation Operators" ); eoValueParam<double>& onePointRateParam = _parser.createParam(double(1.0), "onePointRate", "Relative rate for one point crossover", '1', "Variation Operators" );
// minimum check // minimum check
if ( (onePointRateParam.value() < 0) ) if ( (onePointRateParam.value() < 0) )
throw runtime_error("Invalid onePointRate"); throw std::runtime_error("Invalid onePointRate");
eoValueParam<double>& twoPointsRateParam = _parser.createParam(double(1.0), "twoPointRate", "Relative rate for two point crossover", '2', "Variation Operators" ); eoValueParam<double>& twoPointsRateParam = _parser.createParam(double(1.0), "twoPointRate", "Relative rate for two point crossover", '2', "Variation Operators" );
// minimum check // minimum check
if ( (twoPointsRateParam.value() < 0) ) if ( (twoPointsRateParam.value() < 0) )
throw runtime_error("Invalid twoPointsRate"); throw std::runtime_error("Invalid twoPointsRate");
eoValueParam<double>& uRateParam = _parser.createParam(double(2.0), "uRate", "Relative rate for uniform crossover", 'U', "Variation Operators" ); eoValueParam<double>& uRateParam = _parser.createParam(double(2.0), "uRate", "Relative rate for uniform crossover", 'U', "Variation Operators" );
// minimum check // minimum check
if ( (uRateParam.value() < 0) ) if ( (uRateParam.value() < 0) )
throw runtime_error("Invalid uRate"); throw std::runtime_error("Invalid uRate");
// minimum check // minimum check
bool bCross = true; bool bCross = true;
if (onePointRateParam.value()+twoPointsRateParam.value()+uRateParam.value()==0) if (onePointRateParam.value()+twoPointsRateParam.value()+uRateParam.value()==0)
{ {
cerr << "Warning: no crossover" << endl; std::cerr << "Warning: no crossover" << std::endl;
bCross = false; bCross = false;
} }
@ -146,23 +146,23 @@ eoGenOp<EOT> & do_make_op(eoParser& _parser, eoState& _state, eoInit<EOT>& _init
eoValueParam<double> & pMutPerBitParam = _parser.createParam(0.01, "pMutPerBit", "Probability of flipping 1 bit in bit-flip mutation", 'b', "Variation Operators" ); eoValueParam<double> & pMutPerBitParam = _parser.createParam(0.01, "pMutPerBit", "Probability of flipping 1 bit in bit-flip mutation", 'b', "Variation Operators" );
// minimum check // minimum check
if ( (pMutPerBitParam.value() < 0) || (pMutPerBitParam.value() > 0.5) ) if ( (pMutPerBitParam.value() < 0) || (pMutPerBitParam.value() > 0.5) )
throw runtime_error("Invalid pMutPerBit"); throw std::runtime_error("Invalid pMutPerBit");
eoValueParam<double> & bitFlipRateParam = _parser.createParam(0.01, "bitFlipRate", "Relative rate for bit-flip mutation", 's', "Variation Operators" ); eoValueParam<double> & bitFlipRateParam = _parser.createParam(0.01, "bitFlipRate", "Relative rate for bit-flip mutation", 's', "Variation Operators" );
// minimum check // minimum check
if ( (bitFlipRateParam.value() < 0) ) if ( (bitFlipRateParam.value() < 0) )
throw runtime_error("Invalid bitFlipRate"); throw std::runtime_error("Invalid bitFlipRate");
eoValueParam<double> & oneBitRateParam = _parser.createParam(0.01, "oneBitRate", "Relative rate for deterministic bit-flip mutation", 'd', "Variation Operators" ); eoValueParam<double> & oneBitRateParam = _parser.createParam(0.01, "oneBitRate", "Relative rate for deterministic bit-flip mutation", 'd', "Variation Operators" );
// minimum check // minimum check
if ( (oneBitRateParam.value() < 0) ) if ( (oneBitRateParam.value() < 0) )
throw runtime_error("Invalid oneBitRate"); throw std::runtime_error("Invalid oneBitRate");
// minimum check // minimum check
bool bMut = true; bool bMut = true;
if (bitFlipRateParam.value()+oneBitRateParam.value()==0) if (bitFlipRateParam.value()+oneBitRateParam.value()==0)
{ {
cerr << "Warning: no mutation" << endl; std::cerr << "Warning: no mutation" << std::endl;
bMut = false; bMut = false;
} }

13
eo/src/gp/eoParseTree.h
View file

@ -37,7 +37,6 @@
#include <eoInit.h> #include <eoInit.h>
using namespace gp_parse_tree; using namespace gp_parse_tree;
using namespace std;
/** /**
\defgroup ParseTree \defgroup ParseTree
@ -93,7 +92,7 @@ public :
/** /**
* To read me from a stream * To read me from a stream
* @param is The istream * @param is The std::istream
*/ */
eoParseTree(std::istream& is) : EO<FType>(), parse_tree<Node>() eoParseTree(std::istream& is) : EO<FType>(), parse_tree<Node>()
@ -102,11 +101,11 @@ public :
} }
/// My class name /// My class name
string className(void) const { return "eoParseTree"; } std::string className(void) const { return "eoParseTree"; }
/** /**
* To print me on a stream * To print me on a stream
* @param os The ostream * @param os The std::ostream
*/ */
void printOn(std::ostream& os) const void printOn(std::ostream& os) const
{ {
@ -120,7 +119,7 @@ public :
/** /**
* To read me from a stream * To read me from a stream
* @param is The istream * @param is The std::istream
*/ */
void readFrom(std::istream& is) void readFrom(std::istream& is)
{ {
@ -132,7 +131,7 @@ public :
is >> sz; is >> sz;
vector<Node> v(sz); std::vector<Node> v(sz);
unsigned i; unsigned i;
@ -158,7 +157,7 @@ public :
fitness(fit); fitness(fit);
std::copy(istream_iterator<Node>(is), istream_iterator<Node>(), back_inserter(*this)); std::copy(std::istream_iterator<Node>(is), std::istream_iterator<Node>(), back_inserter(*this));
*/ */
} }
}; };

Some files were not shown because too many files have changed in this diff Show more