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

The BIG change of general operator interface

Browse source 
I also changed
  - the eoQuadratic into eoQuad (as dicussed with Maarten)
  - the eoBin into eoBit, with more appropriate names for the "binary"
    operators (that can be unary!) as no one protested when I posted on
    eodev list
This commit is contained in:
evomarc 2001-02-09 05:09:26 +00:00
commit 415b419671
60 changed files with 2034 additions and 940 deletions
Download patch file Download diff file Expand all files Collapse all files

2
eo/src/Makefile.am
View file

@ -11,4 +11,4 @@ lib_LIBRARIES = libeo.a
libeo_a_SOURCES = eoPrintable.cpp eoPersistent.cpp eoFunctorStore.cpp
libeoincdir = $(includedir)/eo
libeoinc_HEADERS = eo EO.h apply.h eoAlgo.h eoBackInserter.h eoBreed.h eoCombinedContinue.h eoContinue.h eoCounter.h eoDetSelect.h eoDetTournamentInserter.h eoDetTournamentSelect.h eoEasyEA.h eoEvalFunc.h eoEvalFuncPtr.h eoEvolutionStrategy.h eoFactory.h eoFitContinue.h eoFitnessScalingSelect.h eoFixedLength.h eoFunctor.h eoFunctorStore.h eoGOpBreeder.h eoGOpSelector.h eoGenContinue.h eoGenericBinOp.h eoGenericMonOp.h eoGenericQuadOp.h eoIndiSelector.h eoInit.h eoInplaceTransform.h eoInserter.h eoMerge.h eoMergeReduce.h eoObject.h eoOp.h eoOpFactory.h eoOpSelMason.h eoOpSelector.h eoPersistent.h eoPop.h eoPrintable.h eoProportionalCombinedOp.h eoProportionalGOpSel.h eoProportionalOpSel.h eoProportionalSelect.h eoRandomSelect.h eoRankingSelect.h eoReduce.h eoReduceMerge.h eoReplacement.h eoSGA.h eoSGATransform.h eoScalarFitness.h eoSelect.h eoSelectFactory.h eoSelectMany.h eoSelectNumber.h eoSelectOne.h eoSelectPerc.h eoSequentialGOpSel.h eoSteadyFitContinue.h eoSteadyStateEA.h eoSteadyStateInserter.h eoSteadyStateTransform.h eoStochTournamentInserter.h eoStochTournamentSelect.h eoSurviveAndDie.h eoTransform.h eoVariableLength.h eoVariableLengthCrossover.h eoVariableLengthMutation.h eoWrappedOps.h es.h ga.h
libeoinc_HEADERS = eo EO.h apply.h eoAlgo.h eoBreed.h eoCombinedContinue.h eoContinue.h eoCounter.h eoDetSelect.h eoDetTournamentSelect.h eoEasyEA.h eoEvalFunc.h eoEvalFuncPtr.h eoEvolutionStrategy.h eoFactory.h eoFitContinue.h eoFitnessScalingSelect.h eoFixedLength.h eoFunctor.h eoFunctorStore.h eoGenContinue.h eoGenericBinOp.h eoGenericMonOp.h eoGenericQuadOp.h eoInit.h eoMerge.h eoMergeReduce.h eoObject.h eoOp.h eoOpSelMason.h eoPersistent.h eoPop.h eoPrintable.h eoProportionalCombinedOp.h eoProportionalSelect.h eoRandomSelect.h eoRankingSelect.h eoReduce.h eoReduceMerge.h eoReplacement.h eoSGA.h eoSGATransform.h eoScalarFitness.h eoSelect.h eoSelectFactory.h eoSelectMany.h eoSelectNumber.h eoSelectOne.h eoSelectPerc.h eoSteadyFitContinue.h eoStochTournamentSelect.h eoSurviveAndDie.h eoTransform.h eoVariableLength.h eoVariableLengthCrossover.h eoVariableLengthMutation.h es.h ga.h

101
eo/src/eoEvolutionStrategy.h
View file

@ -1,101 +0,0 @@
// -*- mode: c++; c-indent-level: 4; c++-member-init-indent: 8; comment-column: 35; -*-
//-----------------------------------------------------------------------------
// eoEvolutionStrategy.h
// (c) Maarten Keijzer 2000, GeNeura Team, 1998
/*
This library is free software; you can redistribute it and/or
modify it under the terms of the GNU Lesser General Public
License as published by the Free Software Foundation; either
version 2 of the License, or (at your option) any later version.
This library is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
Lesser General Public License for more details.
You should have received a copy of the GNU Lesser General Public
License along with this library; if not, write to the Free Software
Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
Contact: todos@geneura.ugr.es, http://geneura.ugr.es
*/
//-----------------------------------------------------------------------------
#ifndef _eoEvolutionStrategy_h
#define _eoEvolutionStrategy_h
//-----------------------------------------------------------------------------
#include <eoEasyEA.h>
#include <eoInplaceTransform.h>
/** eoEvolutionStrategy:
*/
template<class EOT>
class eoEvolutionStrategy: public eoAlgo<EOT>
{
public:
struct plus_strategy{};
struct comma_strategy{};
eoEvolutionStrategy(
eoContinue<EOT>& _continuator,
eoEvalFunc<EOT>& _eval,
eoGOpSelector<EOT>& _opSel,
float _lambdaRate,
comma_strategy)
: selectPerc(randomSelect, _lambdaRate),
transform(_opSel),
easyEA(_continuator, _eval, selectPerc, transform, noElitism, truncate)
{}
eoEvolutionStrategy(
eoContinue<EOT>& _continuator,
eoEvalFunc<EOT>& _eval,
eoGOpSelector<EOT>& _opSel,
float _lambdaRate,
plus_strategy)
: selectPerc(randomSelect, _lambdaRate),
transform(_opSel),
easyEA(_continuator, _eval, selectPerc, transform, plus, truncate)
{}
/// Apply a few generation of evolution to the population.
virtual void operator()(eoPop<EOT>& _pop)
{
easyEA(_pop);
}
private:
eoPlus<EOT> plus;
eoNoElitism<EOT> noElitism;
eoTruncate<EOT> truncate;
eoRandomSelect<EOT> randomSelect;
eoSelectPerc<EOT> selectPerc;
eoInplaceTransform2<EOT> transform;
/// easyEA is contained rather than a base because of member initialization order!
eoEasyEA<EOT> easyEA;
};
template <class EOT>
eoEvolutionStrategy<EOT> make_es(eoContinue<EOT>& _continuator,
eoEvalFunc<EOT>& _eval,
eoGOpSelector<EOT>& _opSel,
float _lambdaRate,
bool _comma)
{
if (_comma)
return eoEvolutionStrategy<EOT>(_continuator, _eval, _opSel, _lambdaRate, eoEvolutionStrategy<EOT>::comma_strategy());
//else
return eoEvolutionStrategy<EOT>(_continuator, _eval, _opSel, _lambdaRate, eoEvolutionStrategy<EOT>::plus_strategy());
}
//-----------------------------------------------------------------------------
#endif eoSelectTransformReduce_h

160
eo/src/eoGenOp.h Normal file
View file

@ -0,0 +1,160 @@
// -*- mode: c++; c-indent-level: 4; c++-member-init-indent: 8; comment-column: 35; -*-
//-----------------------------------------------------------------------------
// eoGenOp.h
// (c) Maarten Keijzer and Marc Schoenauer, 2001
/*
This library is free software; you can redistribute it and/or
modify it under the terms of the GNU Lesser General Public
License as published by the Free Software Foundation; either
version 2 of the License, or (at your option) any later version.
This library is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
Lesser General Public License for more details.
You should have received a copy of the GNU Lesser General Public
License along with this library; if not, write to the Free Software
Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
Contact: mkeijzer@dhi.dk
Marc.Schoenauer@polytechnique.fr
*/
//-----------------------------------------------------------------------------
#ifndef _eoGenOp_H
#define _eoGenOp_H
#include <eoOp.h>
#include <eoPopulator.h>
/** @name General variation operators
a class that allows to use i->j operators for any i and j
thanks to the friend class eoPopulator
@author Maarten Keijzer
@version 0.0
*/
/** The base class for General Operators
*/
template <class EOT>
class eoGenOp : public eoOp<EOT>, public eoUF<eoPopulator<EOT> &, void>
{
public :
/// Ctor that honors its superclass
eoGenOp(): eoOp<EOT>( eoOp<EOT>::general ) {}
virtual unsigned max_production(void) = 0;
virtual string className() = 0;
void operator()(eoPopulator<EOT>& _pop)
{
_pop.reserve(max_production());
apply(_pop);
}
protected :
/** the function that will do the work
*/
virtual void apply(eoPopulator<EOT>& _pop) = 0;
};
/** Wrapper for eoMonOp */
template <class EOT>
class eoMonGenOp : public eoGenOp<EOT>
{
public:
eoMonGenOp(eoMonOp<EOT>& _op) : op(_op) {}
unsigned max_production(void) { return 1; }
void apply(eoPopulator<EOT>& _it)
{
op(*_it); // look how simple
}
string className() {return op.className();}
private :
eoMonOp<EOT>& op;
};
/** Wrapper for binop: here we use erase method of eoPopulator
* but we could also have an embedded selector to select the second parent
*/
template <class EOT>
class eoBinGenOp : public eoGenOp<EOT>
{
public:
eoBinGenOp(eoBinOp<EOT>& _op) : op(_op) {}
unsigned max_production(void) { return 1; }
/** do the work: get 2 individuals from the population, modifies
only one (it's a eoBinOp) and erases the non-midified one
*/
void apply(eoPopulator<EOT>& _pop)
{
EOT& a = *_pop;
EOT& b = *++_pop;
op(a, b);
_pop.erase();
}
string className() {return op.className();}
private :
eoBinOp<EOT>& op;
};
/** wrapper for eoBinOp with a selector */
template <class EOT>
class eoSelBinGenOp : public eoGenOp<EOT>
{
public:
eoSelBinGenOp(eoBinOp<EOT>& _op, eoSelectOne<EOT>& _sel) :
op(_op), sel(_sel) {}
unsigned max_production(void) { return 1; }
void apply(eoPopulator<EOT>& _pop)
{ // _pop.source() gets the original population, an eoVecOp can make use of this as well
op(*_pop, sel(_pop.source()));
}
string className() {return op.className();}
private :
eoBinOp<EOT>& op;
eoSelectOne<EOT>& sel;
};
/** Wrapper for quadop: easy as pie
*/
template <class EOT>
class eoQuadGenOp : public eoGenOp<EOT>
{
public:
eoQuadGenOp(eoQuadOp<EOT>& _op) : op(_op) {}
unsigned max_production(void) { return 2; }
void apply(eoPopulator<EOT>& _pop)
{
EOT& a = *_pop;
EOT& b = *++_pop;
op(a, b);
}
string className() {return op.className();}
private :
eoQuadOp<EOT>& op;
};
#endif

88
eo/src/eoGeneralBreeder.h Normal file
View file

@ -0,0 +1,88 @@
// -*- mode: c++; c-indent-level: 4; c++-member-init-indent: 8; comment-column: 35; -*-
//-----------------------------------------------------------------------------
// eoGeneralBreeder.h
// (c) Maarten Keijzer and Marc Schoenauer, 2001
/*
This library is free software; you can redistribute it and/or
modify it under the terms of the GNU Lesser General Public
License as published by the Free Software Foundation; either
version 2 of the License, or (at your option) any later version.
This library is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
Lesser General Public License for more details.
You should have received a copy of the GNU Lesser General Public
License along with this library; if not, write to the Free Software
Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
Contact: mkeijzer@dhi.dk
Marc.Schoenauer@polytechnique.fr
*/
//-----------------------------------------------------------------------------
#ifndef eoGeneralBreeder_h
#define eoGeneralBreeder_h
//-----------------------------------------------------------------------------
/*****************************************************************************
* eoGeneralBreeder: transforms a population using the generalOp construct.
*****************************************************************************/
#include <eoOp.h>
#include <eoPopulator.h>
/**
Base class for breeders using generalized operators.
*/
template<class EOT>
class eoGeneralBreeder: public eoBreed<EOT>
{
public:
/** Ctor:
*
* @param _select a selectoOne, to be used for all selections
* @param _op a general operator (will generally be an eoOpContainer)
* @param _rate pour howMany, le nbre d'enfants a generer
* @param _interpret_as_rate <a href="../../tutorial/html/eoEngine.html#howmany">explanation</a>
*/
eoGeneralBreeder( eoSelectOne<EOT>& _select, eoGenOp<EOT>& _op,
double _rate=1.0, bool _interpret_as_rate = true) :
select( _select ), op(_op), howMany(_rate, _interpret_as_rate) {}
/** The breeder: simply calls the genOp on a selective populator!
*
* @param _parents the initial population
* @param _offspring the resulting population (content -if any- is lost)
*/
void operator()(const eoPop<EOT>& _parents, eoPop<EOT>& _offspring)
{
unsigned target = howMany(_parents.size());
eoSelectivePopulator<EOT> it(_parents, select);
select.setup(_parents);
while (it.size() < target)
{
op(it);
}
swap(_offspring, it);
_offspring.resize(target); // you might have generated a few more
}
/// The class name.
string className() const { return "eoGeneralBreeder"; }
private:
eoSelectOne<EOT>& select;
eoGenOp<EOT>& op;
eoHowMany howMany;
};
#endif eoBreeder_h

61
eo/src/eoOp.h
View file

@ -35,11 +35,22 @@ Genetic Operators are used for various purposes
/** @name Genetic operators
What is a genetic algorithm without genetic operators? There is a genetic operator hierarchy, with eoOp as father and eoMonOp (monary or unary operator) and eoBinOp and eoQuadraticOp (binary operators) as siblings). Nobody should subclass eoOp, you should subclass eoGeneralOp, eoBinOp, eoQuadraticOp or eoMonOp, those are the ones actually used here. \\#eoOp#s are only printable objects, so if you want to build them from a file, it has to be done in another class, namely factories. Each hierarchy of #eoOp#s should have its own factory, which know how to build them from a description in a file.
What is a genetic algorithm without genetic operators?
There is a genetic operator hierarchy, with eoOp as father and
eoMonOp (monary or unary operator), eoBinOp and eoQuadOp (binary operators)
and eoGenOp (any number of inputs and outputs, see eoGenOp.h)
as subclasses.
Nobody should subclass eoOp, you should subclass eoGenOp, eoBinOp, eoQuadOp
or eoMonOp, those are the ones actually used here.
@author GeNeura Team
@version 0.1
@see eoOpFactory
#eoOp#s are only printable objects, so if you want to build them
from a file, it has to be done in another class, namely factories.
Each hierarchy of #eoOp#s should have its own factory, which know
how to build them from a description in a file.
@author GeNeura Team, Marten Keijzer and Marc Schoenauer
@version 0.9
@see eoGenOp.h eoOpFactory
*/
@ -102,17 +113,14 @@ public:
virtual string className() const {return "eoBinOp";};
};
// planning the change of name eoQuadraticOp --> eoQuadOp
#define eoQuadraticOp eoQuadOp
/** Quadratic genetic operator: subclasses eoOp, and defines basically the
/** Quad genetic operator: subclasses eoOp, and defines basically the
operator() with two operands, both can be modified.
*/
template<class EOType>
class eoQuadraticOp: public eoOp<EOType>, public eoBF<EOType&, EOType&, void> {
class eoQuadOp: public eoOp<EOType>, public eoBF<EOType&, EOType&, void> {
public:
/// Ctor
eoQuadraticOp()
eoQuadOp()
:eoOp<EOType>( eoOp<EOType>::quadratic ) {};
virtual string className() const {return "eoQuadOp";};
};
@ -145,38 +153,5 @@ private:
eoQuadOp<EOT> & quadOp;
};
// some forward declarations
template<class EOT>
class eoIndiSelector;
template<class EOT>
class eoInserter;
/**
* eGeneralOp: General genetic operator; for objects used to transform sets
* of EOs. Nary ("orgy") operators should be derived from this class
Derived from eoB(inary)F(unction)
Applies the genetic operator
to a individuals dispensed by an eoIndividualSelector,
and puts the results in the eoIndividualInserter.
Any number of inputs can be requested and any number of outputs
can be produced.
*/
template<class EOT>
class eoGeneralOp: public eoOp<EOT>, public eoBF<eoIndiSelector<EOT>&, eoInserter<EOT>&, void>
{
public:
/// Ctor that honors its superclass
eoGeneralOp(): eoOp<EOT>( eoOp<EOT>::general ) {}
};
#endif

201
eo/src/eoOpContainer.h Normal file
View file

@ -0,0 +1,201 @@
// -*- mode: c++; c-indent-level: 4; c++-member-init-indent: 8; comment-column: 35; -*-
//-----------------------------------------------------------------------------
// eoOpContainer.h
// (c) Maarten Keijzer and Marc Schoenauer, 2001
/*
This library is free software; you can redistribute it and/or
modify it under the terms of the GNU Lesser General Public
License as published by the Free Software Foundation; either
version 2 of the License, or (at your option) any later version.
This library is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
Lesser General Public License for more details.
You should have received a copy of the GNU Lesser General Public
License along with this library; if not, write to the Free Software
Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
Contact: mkeijzer@dhi.dk
Marc.Schoenauer@polytechnique.fr
*/
//-----------------------------------------------------------------------------
#ifndef _eoOpContainer_H
#define _eoOpContainer_H
#include <eoGenOp.h>
/** eoOpContainer is a base class for the sequential and proportional selectors
* It takes care of wrapping the other operators,
* and deleting stuff that it has allocated
*
* Warning: all operators are added together with a rate (double)
* However, the meaning of this rate will be different in
* the differnet instances of eoOpContainer:
* an ***absolute*** probability in the sequential version, and
* a ***relative*** weight in the proportional version
*/
template <class EOT>
class eoOpContainer : public eoGenOp<EOT>
{
public :
/** Ctor: nothing much to do */
eoOpContainer() : max_to_produce(0) {}
/** Dtor: delete all the GenOps created when wrapping simple ops
*/
virtual ~eoOpContainer(void)
{
for (unsigned i = 0; i < owned_genops.size(); ++i)
delete owned_genops[i];
}
/** for memory management (doesn't have to be very precise */
virtual unsigned max_production(void)
{
return max_to_produce;
}
/** wraps then add a simple eoMonOp */
void add(eoMonOp<EOT>& _op, double _rate)
{
owned_genops.push_back(new eoMonGenOp<EOT>(_op));
ops.push_back(owned_genops.back());
rates.push_back(_rate);
max_to_produce = max(max_to_produce,unsigned(1));
}
/** wraps then add a simple eoBinOp
* First case, no selector
*/
void add(eoBinOp<EOT>& _op, double _rate)
{
owned_genops.push_back(new eoBinGenOp<EOT>(_op));
ops.push_back(owned_genops.back());
rates.push_back(_rate);
max_to_produce = max(max_to_produce,unsigned(1));
}
/** wraps then add a simple eoBinOp
* Second case: a sepecific selector
*/
void add(eoBinOp<EOT>& _op, eoSelectOne<EOT> & _sel, double _rate)
{
owned_genops.push_back(new eoSelBinGenOp<EOT>(_op, _sel));
ops.push_back(owned_genops.back());
rates.push_back(_rate);
max_to_produce = max(max_to_produce,unsigned(1));
}
/** wraps then add a simple eoQuadOp */
void add(eoQuadOp<EOT>& _op, double _rate)
{
owned_genops.push_back(new eoQuadGenOp<EOT>(_op));
ops.push_back(owned_genops.back());
rates.push_back(_rate);
max_to_produce = max(max_to_produce,unsigned(2));
}
/** can add any GenOp */
void add(eoGenOp<EOT>& _op, double _rate)
{
ops.push_back(&_op);
rates.push_back(_rate);
max_to_produce = max(max_to_produce,_op.max_production());
}
virtual string className() = 0;
protected :
vector<double> rates;
vector<eoGenOp<EOT>*> ops;
private :
vector<eoGenOp<EOT>*> owned_genops;
unsigned max_to_produce;
};
/** Sequential selection:
* note the mark, rewind, unmark cycle
* here operators are repeatedly applied on the same individual(s)
* not all too elegant, but it sort of works...
*/
template <class EOT>
class eoSequentialOp : public eoOpContainer<EOT>
{
public :
typedef unsigned position_type;
void apply(eoPopulator<EOT>& _pop)
{
position_type pos = _pop.tellp();
for (size_t i = 0; i < rates.size(); ++i)
{
_pop.seekp(pos);
do
{
if (eo::rng.flip(rates[i]))
{
// try
// {
// apply it to all the guys in the todo list
(*ops[i])(_pop);
// }
// check for out of individuals and do nothing with that...
// catch(eoPopulator<EOT>::OutOfIndividuals&)
// {
// cout << "Warning: not enough individuals to handle\n";
// return ;
// }
}
if (!_pop.exhausted())
++_pop;
}
while (!_pop.exhausted());
}
}
virtual string className() {return "SequentialOp";}
private :
vector<size_t> to_apply;
vector<size_t> production;
};
/** The proportinoal verions: easy! */
template <class EOT>
class eoProportionalOp : public eoOpContainer<EOT>
{
public :
void apply(eoPopulator<EOT>& _pop)
{
unsigned i = eo::rng.roulette_wheel(rates);
try
{
(*ops[i])(_pop);
}
catch(eoPopulator<EOT>::OutOfIndividuals&)
{}
}
virtual string className() {return "ProportionalOp";}
};
#endif

169
eo/src/eoPopulator.h Normal file
View file

@ -0,0 +1,169 @@
// -*- mode: c++; c-indent-level: 4; c++-member-init-indent: 8; comment-column: 35; -*-
//-----------------------------------------------------------------------------
// eoPopulator.h
// (c) Maarten Keijzer and Marc Schoenauer, 2001
/*
This library is free software; you can redistribute it and/or
modify it under the terms of the GNU Lesser General Public
License as published by the Free Software Foundation; either
version 2 of the License, or (at your option) any later version.
This library is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
Lesser General Public License for more details.
You should have received a copy of the GNU Lesser General Public
License along with this library; if not, write to the Free Software
Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
Contact: mkeijzer@dhi.dk
Marc.Schoenauer@polytechnique.fr
*/
//-----------------------------------------------------------------------------
#ifndef _eoPopulator_H
#define _eoPopulator_H
#include <eoPop.h>
#include <eoSelectOne.h>
template <class EOT>
class eoPopulator : public eoPop<EOT>
{
public :
eoPopulator(const eoPop<EOT>& _src) : current(begin()), src(_src) {}
struct OutOfIndividuals {};
/** a populator behaves like an iterator. Hence the operator*
* it returns the current individual -- eventually getting
* a new one through the operator++ if at the end
*/
EOT& operator*(void)
{
if (current == end())
operator++();
return *current;
}
/** only prefix increment defined
* if needed, adds a new individual using the embedded selector
* and set the current pointer to the newly inserted individual
* otherwise simply increment the current pointer
*/
eoPopulator& operator++()
{
if (current == end())
{ // get new individual from derived class select()
push_back(select());
current = end();
--current;
return *this;
}
// else
++current;
return *this;
}
/** mandatory for operators that generate more offspring than parents
* if such a thing exists ?
*/
void insert(const EOT& _eo)
{ /* not really efficient, but its nice to have */
current = eoPop<EOT>::insert(current, _eo);
}
/** useful for operators that generate less offspring than parents
* though there is another way - using a selector *within*
* the operator to get the extra parents from outside
*/
void erase()
{
current = eoPop<EOT>::erase(current);
}
/** just to make memory mangement more efficient
*/
void reserve(int how_many)
{
size_t sz = current - begin();
eoPop<EOT>::reserve(size() + how_many);
current = begin() + sz;
}
/** can be useful for operators with embedded selectors
* e.g. your barin and my beauty -type
*/
const eoPop<EOT>& source(void) { return src; }
typedef unsigned position_type;
/** this is a direct access container: tell position */
position_type tellp() { return current - begin(); }
/** this is a direct access container: go to position */
void seekp(position_type pos) { current = begin() + pos; }
/** no more individuals */
bool exhausted(void) { return current == end(); }
protected :
/** the pure virtual selection method - will be instanciated in
* eoSeqPopulator and eoPropPopulator
*/
virtual const EOT& select() = 0;
eoPop<EOT>::iterator current;
const eoPop<EOT>& src;
};
/** SeqPopulator: an eoPopulator that sequentially goes through the population
is supposed to be used after a batch select of a whole bunch or genitors
*/
template <class EOT>
class eoSeqPopulator : public eoPopulator<EOT>
{
public :
eoSeqPopulator(const eoPop<EOT>& _pop) :
eoPopulator<EOT>(_pop), src_it(_pop.begin()) {}
const EOT& select(void)
{
if (src_it == src.end())
{
throw OutOfIndividuals();
}
const EOT& res = *src_it++;
return res;
}
private :
vector<EOT>::const_iterator src_it;
};
/** SelectivePopulator an eoPoplator that uses an eoSelectOne to select guys.
Supposedly, it is passed the initial population.
*/
template <class EOT>
class eoSelectivePopulator : public eoPopulator<EOT>
{
public :
eoSelectivePopulator(const eoPop<EOT>& _pop, eoSelectOne<EOT>& _sel)
: eoPopulator<EOT>(_pop), sel(_sel) {}
const EOT& select()
{
return sel(src);
}
private :
eoSelectOne<EOT>& sel;
};
#endif

12
eo/src/eoProportionalCombinedOp.h
View file

@ -172,21 +172,21 @@ std::vector<double> rates;
//// combined QuadOp
//////////////////////////////////////////////////////
/** Quadratic genetic operator: subclasses eoOp, and defines basically the
/** Quad genetic operator: subclasses eoOp, and defines basically the
operator() with two operands, both can be modified.
*/
/** COmbined quadratic genetic operator:
/** Combined quad genetic operator:
* operator() has two operands, both can be modified
* generic operators are now allowed: there are imbedded into
* the corresponding "true" operator
*/
template <class EOT>
class eoPropCombinedQuadOp: public eoQuadraticOp<EOT>
class eoPropCombinedQuadOp: public eoQuadOp<EOT>
{
public:
/// Ctor from a true operator
eoPropCombinedQuadOp(eoQuadraticOp<EOT> & _first, const double _rate)
eoPropCombinedQuadOp(eoQuadOp<EOT> & _first, const double _rate)
{
ops.push_back(&_first);
rates.push_back(_rate);
@ -204,7 +204,7 @@ public:
virtual string className() const { return "eoPropCombinedQuadOp"; }
// addition of a true operator
virtual void add(eoQuadraticOp<EOT> & _op, const double _rate, bool _verbose=false)
virtual void add(eoQuadOp<EOT> & _op, const double _rate, bool _verbose=false)
{
ops.push_back(&_op);
rates.push_back(_rate);
@ -242,7 +242,7 @@ virtual void add(eoGenericQuadOp<EOT> & _op, const double _rate, bool _verbose=f
(*ops[what])(_indi1, _indi2); // apply it
}
private:
std::vector<eoQuadraticOp<EOT>*> ops;
std::vector<eoQuadOp<EOT>*> ops;
std::vector<double> rates;
};

6
eo/src/eoSGA.h
View file

@ -37,7 +37,7 @@
#include <apply.h>
/** The Simple Genetic Algorithm, following Holland and Goldberg
* Needs a selector (class eoSelectOne) a crossover (eoQuadratic,
* Needs a selector (class eoSelectOne) a crossover (eoQuad,
* i.e. a 2->2 operator) and a mutation with their respective rates,
* of course an evaluation function (eoEvalFunc) and a continuator
* (eoContinue) which gives the stopping criterion. Performs full
@ -53,7 +53,7 @@ public :
// in the one above. Any objection :-) MS
eoSGA(
eoSelectOne<EOT>& _select,
eoQuadraticOp<EOT>& _cross, float _crate,
eoQuadOp<EOT>& _cross, float _crate,
eoMonOp<EOT>& _mutate, float _mrate,
eoEvalFunc<EOT>& _eval,
eoContinue<EOT>& _cont)
@ -103,7 +103,7 @@ private :
eoContinue<EOT>& cont;
eoMonOp<EOT>& mutate;
float mutationRate;
eoQuadraticOp<EOT>& cross;
eoQuadOp<EOT>& cross;
float crossoverRate;
eoSelectPerc<EOT> select;
eoEvalFunc<EOT>& eval;

10
eo/src/eoSGATransform.h
View file

@ -48,7 +48,7 @@ template<class EOT> class eoSGATransform : public eoTransform<EOT>
public:
/// Default constructor.
eoSGATransform(eoQuadraticOp<EOT>& _cross, double _cProba,
eoSGATransform(eoQuadOp<EOT>& _cross, double _cProba,
eoMonOp<EOT>& _mutate, double _mProba)
: cross(_cross),
crossoverProba(_cProba),
@ -84,7 +84,7 @@ template<class EOT> class eoSGATransform : public eoTransform<EOT>
};
private:
eoQuadraticOp<EOT>& cross;
eoQuadOp<EOT>& cross;
double crossoverProba;
eoMonOp<EOT>& mutate;
double mutationProba;
@ -102,7 +102,7 @@ template<class EOT> class eoDynSGATransform : public eoTransform<EOT>
public:
/// Default constructor - receives values
eoDynSGATransform(eoQuadraticOp<EOT>& _cross, double _cProba,
eoDynSGATransform(eoQuadOp<EOT>& _cross, double _cProba,
eoMonOp<EOT>& _mutate, double _mProba)
: cross(_cross),
crossoverProbaHolder(_cProba), crossoverProba(crossoverProbaHolder),
@ -112,7 +112,7 @@ template<class EOT> class eoDynSGATransform : public eoTransform<EOT>
/// This constructor receives pointers
// these will usually be some eoValueParam<double>.value()
// hence the ...Holder data will bever be used in this case
eoDynSGATransform(eoQuadraticOp<EOT>& _cross, double* _cProbaRef,
eoDynSGATransform(eoQuadOp<EOT>& _cross, double* _cProbaRef,
eoMonOp<EOT>& _mutate, double* _mProbaRef)
: cross(_cross),
crossoverProbaHolder(0), crossoverProba(*_cProbaRef),
@ -154,7 +154,7 @@ private:
// difference with eoSGATransform: the operator probabilities
// they can be passed by reference or by value.
// hence we need here to use a reference, and to eventually store a value
eoQuadraticOp<EOT>& cross;
eoQuadOp<EOT>& cross;
double crossoverProbaHolder; // the value, used only if ctor gets a value
double& crossoverProba; // the reference, to be used in operator()
eoMonOp<EOT>& mutate;

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

@ -41,7 +41,7 @@ Simply calls a crossover for the object variables,
*/
template <class EOT>
class eoEsStdevXOver : public eoQuadraticOp<EOT>
class eoEsStdevXOver : public eoQuadOp<EOT>
{
public :
eoEsStdevXOver(eoGenericQuadOp<vector<double> > & _objectXOver,

19
eo/src/es/eoGenericRealOp.h
View file

@ -47,7 +47,10 @@ MS January 25. 2001
/** eoUniformMutation --> changes all values of the vector
by uniform choice with range epsilon
with probability p_change per variable
\class eoUniformMutation eoRealOp.h Tutorial/eoRealOp.h
\ingroup parameteric
*/
template<class EOT> class eoGenericUniformMutation: public eoGenericMonOp<EOT>
{
public:
@ -110,6 +113,8 @@ private:
/** eoDetUniformMutation --> changes exactly k values of the vector
by uniform choice with range epsilon
\class eoDetUniformMutation eoRealOp.h Tutorial/eoRealOp.h
\ingroup parameteric
*/
template<class EOT> class eoGenericDetUniformMutation:
@ -168,10 +173,14 @@ private:
};
// two arithmetical crossovers
/** eoSegmentCrossover --> uniform choice in segment
== arithmetical with same value along all coordinates
== arithmetical with same value along all coordinates
\class eoSegmentCrossover eoRealOp.h Tutorial/eoRealOp.h
\ingroup parameteric
*/
template<class EOT> class eoGenericSegmentCrossover: public eoGenericQuadOp<EOT>
{
public:
@ -257,8 +266,11 @@ protected:
};
/** eoArithmeticCrossover --> uniform choice in hypercube
== arithmetical with different values for each coordinate
== arithmetical with different values for each coordinate
\class eoArithmeticCrossover eoRealOp.h Tutorial/eoRealOp.h
\ingroup parameteric
*/
template<class EOT> class eoGenericArithmeticCrossover:
public eoGenericQuadOp<EOT>
{
@ -354,7 +366,10 @@ protected:
/** eoRealUxOver --> Uniform crossover, also termed intermediate crossover
\class eoRealUxOver eoRealOp.h Tutorial/eoRealOp.h
\ingroup parameteric
*/
template<class EOT> class eoGenericRealUxOver: public eoGenericQuadOp<EOT>
{
public:

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

@ -168,7 +168,7 @@ private:
\ingroup parameteric
*/
template<class EOT> class eoSegmentCrossover: public eoQuadraticOp<EOT>
template<class EOT> class eoSegmentCrossover: public eoQuadOp<EOT>
{
public:
/**
@ -259,7 +259,7 @@ protected:
\ingroup parameteric
*/
template<class EOT> class eoArithmeticCrossover: public eoQuadraticOp<EOT>
template<class EOT> class eoArithmeticCrossover: public eoQuadOp<EOT>
{
public:
/**
@ -358,7 +358,7 @@ protected:
\ingroup parameteric
*/
template<class EOT> class eoRealUxOver: public eoQuadraticOp<EOT>
template<class EOT> class eoRealUxOver: public eoQuadOp<EOT>
{
public:
/**

4
eo/src/ga.h
View file

@ -30,12 +30,12 @@
#define _ga_h
// all bitstring-specific files
#include <ga/eoBin.h>
#include <ga/eoBit.h>
// the operators
#include <ga/eoBitOp.h>
// #include <ga/eoBitOpFactory.h>
// #include <ga/eoBitOpFactory.h> to be corrected - thanks someone!
//-----------------------------------------------------------------------------

2
eo/src/ga/Makefile.am
View file

@ -5,4 +5,4 @@
###############################################################################
libeoincdir = $(includedir)/eo/ga
libeoinc_HEADERS = eoBin.h eoBitOp.h eoBitOpFactory.h
libeoinc_HEADERS = eoBit.h eoBitOp.h eoBitOpFactory.h

22
eo/src/ga/eoBin.h → eo/src/ga/eoBit.h
View file

@ -1,5 +1,5 @@
/*
eoBin.h
eoBit.h
(c) GeNeura Team 1998, Marc Schoenauer 2000
This library is free software; you can redistribute it and/or
@ -24,10 +24,14 @@
Added the calls to base class I/O routines that print the fitness
Left printing/reading of the size of the bitstring,
for backward compatibility, and as it is a general practice in EO
MS, Feb. 7, 2001
replaced all ...Bin... names with ...Bit... names - for bitstring
as it was ambiguous with bin...ary things
*/
#ifndef eoBin_h
#define eoBin_h
#ifndef eoBit_h
#define eoBit_h
//-----------------------------------------------------------------------------
@ -43,12 +47,12 @@
Various functions for a bitstring representation
*/
/** eoBin: implementation of binary chromosome.
\class eoBin eoBin.h ga/eoBin.h
/** eoBit: implementation of bitstring chromosome.
\class eoBit eoBit.h ga/eoBit.h
\ingroup bitstring
* based on STL's vector<bool> specialization.
*/
template <class FitT> class eoBin: public eoFixedLength<FitT, bool>
template <class FitT> class eoBit: public eoFixedLength<FitT, bool>
{
public:
@ -56,13 +60,13 @@ template <class FitT> class eoBin: public eoFixedLength<FitT, bool>
* (Default) Constructor.
* @param size Size of the binary string.
*/
eoBin(unsigned size = 0, bool value = false):
eoBit(unsigned size = 0, bool value = false):
eoFixedLength<FitT, bool>(size, value) {}
/// My class name.
string className() const
{
return "eoBin";
return "eoBit";
}
/**
@ -99,4 +103,4 @@ template <class FitT> class eoBin: public eoFixedLength<FitT, bool>
//-----------------------------------------------------------------------------
#endif //eoBin_h
#endif //eoBit_h

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

@ -40,7 +40,7 @@
// chrom[i] = (chrom[i]) ? false : true;
// we were calling something like
// specific_mutate(chrom[i])
// all mutation would also be generic ... except those eoBinNext and eoBinPrev
// all mutation would also be generic ... except those eoBitNext and eoBitPrev
// If anybody reads this and want to change that (I'm also testing to see
// if someone ever reads the headers :-), drop me a mail
@ -57,19 +57,19 @@
#include <algorithm> // swap_ranges
#include <utils/eoRNG.h>
#include <eoInit.h> // eoMonOp
#include <ga/eoBin.h>
#include <ga/eoBit.h>
/** eoBinBitFlip --> changes 1 bit
\class eoBinBitFlip eoBitOp.h ga/eoBitOp.h
/** eoBitFlip --> changes 1 bit
\class eoBitBitFlip eoBitOp.h ga/eoBitOp.h
\ingroup bitstring
*/
template<class Chrom> class eoBinBitFlip: public eoMonOp<Chrom>
template<class Chrom> class eoOneBitFlip: public eoMonOp<Chrom>
{
public:
/// The class name.
string className() const { return "eoBinBitFlip"; }
string className() const { return "eoOneBitFlip"; }
/**
* Change one bit.
@ -77,9 +77,9 @@ template<class Chrom> class eoBinBitFlip: public eoMonOp<Chrom>
*/
void operator()(Chrom& chrom)
{
chrom.invalidate();
unsigned i = rng.random(chrom.size());
unsigned i = eo::rng.random(chrom.size());
chrom[i] = (chrom[i]) ? false : true;
chrom.invalidate();
}
};
@ -94,7 +94,7 @@ template<class Chrom> class eoDetBitFlip: public eoMonOp<Chrom>
/**
* (Default) Constructor.
* @param _num_bit The number of bits to change
* default is one - equivalent to eoBinBitFlip then
* default is one - equivalent to eoOneBitFlip then
*/
eoDetBitFlip(const unsigned& _num_bit = 1): num_bit(_num_bit) {}
@ -107,35 +107,35 @@ template<class Chrom> class eoDetBitFlip: public eoMonOp<Chrom>
*/
void operator()(Chrom& chrom)
{
chrom.invalidate();
// does not check for duplicate: if someone volunteers ....
for (unsigned k=0; k<num_bit; k++)
{
unsigned i = rng.random(chrom.size());
unsigned i = eo::rng.random(chrom.size());
chrom[i] = (chrom[i]) ? false : true;
}
chrom.invalidate();
}
private:
unsigned num_bit;
};
/** eoBinMutation --> classical mutation
\class eoBinMutation eoBitOp.h ga/eoBitOp.h
/** eoBitMutation --> classical mutation
\class eoBitMutation eoBitOp.h ga/eoBitOp.h
\ingroup bitstring
*/
template<class Chrom> class eoBinMutation: public eoMonOp<Chrom>
template<class Chrom> class eoBitMutation: public eoMonOp<Chrom>
{
public:
/**
* (Default) Constructor.
* @param _rate Rate of mutation.
*/
eoBinMutation(const double& _rate = 0.01): rate(_rate) {}
eoBitMutation(const double& _rate = 0.01): rate(_rate) {}
/// The class name.
string className() const { return "eoBinMutation"; }
string className() const { return "eoBitMutation"; }
/**
* Mutate a chromosome.
@ -145,7 +145,7 @@ template<class Chrom> class eoBinMutation: public eoMonOp<Chrom>
{
bool changed_something = false;
for (unsigned i = 0; i < chrom.size(); i++)
if (rng.flip(rate))
if (eo::rng.flip(rate))
{
chrom[i] = !chrom[i];
changed_something = true;
@ -160,16 +160,16 @@ template<class Chrom> class eoBinMutation: public eoMonOp<Chrom>
};
/** eoBinInversion: inverts the bits of the chromosome between an interval
\class eoBinInversion eoBitOp.h ga/eoBitOp.h
/** eoBitInversion: inverts the bits of the chromosome between an interval
\class eoBitInversion eoBitOp.h ga/eoBitOp.h
\ingroup bitstring
*/
template<class Chrom> class eoBinInversion: public eoMonOp<Chrom>
template<class Chrom> class eoBitInversion: public eoMonOp<Chrom>
{
public:
/// The class name.
string className() const { return "eoBinInversion"; }
string className() const { return "eoBitInversion"; }
/**
* Inverts a range of bits in a binary chromosome.
@ -178,8 +178,8 @@ template<class Chrom> class eoBinInversion: public eoMonOp<Chrom>
void operator()(Chrom& chrom)
{
unsigned u1 = rng.random(chrom.size() + 1) , u2;
do u2 = rng.random(chrom.size() + 1); while (u1 == u2);
unsigned u1 = eo::rng.random(chrom.size() + 1) , u2;
do u2 = eo::rng.random(chrom.size() + 1); while (u1 == u2);
unsigned r1 = min(u1, u2), r2 = max(u1, u2);
reverse(chrom.begin() + r1, chrom.begin() + r2);
@ -188,16 +188,16 @@ template<class Chrom> class eoBinInversion: public eoMonOp<Chrom>
};
/** eoBinNext --> next binary value
\class eoBinNext eoBitOp.h ga/eoBitOp.h
/** eoBitNext --> next value when bitstring considered as binary value
\class eoBitNext eoBitOp.h ga/eoBitOp.h
\ingroup bitstring
*/
template<class Chrom> class eoBinNext: public eoMonOp<Chrom>
template<class Chrom> class eoBitNext: public eoMonOp<Chrom>
{
public:
/// The class name.
string className() const { return "eoBinNext"; }
string className() const { return "eoBitNext"; }
/**
* Change the bit string x to be x+1.
@ -222,16 +222,16 @@ template<class Chrom> class eoBinNext: public eoMonOp<Chrom>
};
/** eoBinPrev --> previous binary value
\class eoBinPrev eoBitOp.h ga/eoBitOp.h
/** eoBitPrev --> previous value when bitstring treated as binary value
\class eoBitPrev eoBitOp.h ga/eoBitOp.h
\ingroup bitstring
*/
template<class Chrom> class eoBinPrev: public eoMonOp<Chrom>
template<class Chrom> class eoBitPrev: public eoMonOp<Chrom>
{
public:
/// The class name.
string className() const { return "eoBinPrev"; }
string className() const { return "eoBitPrev"; }
/**
* Change the bit string x to be x-1.
@ -256,16 +256,16 @@ template<class Chrom> class eoBinPrev: public eoMonOp<Chrom>
};
/** eoBinCrossover --> classic 1-point crossover
\class eoBinCrossover eoBitOp.h ga/eoBitOp.h
/** eo1PtBitXover --> classic 1-point crossover
\class eo1PtBitCrossover eoBitOp.h ga/eoBitOp.h
\ingroup bitstring
*/
template<class Chrom> class eoBinCrossover: public eoQuadraticOp<Chrom>
template<class Chrom> class eo1PtBitXover: public eoQuadOp<Chrom>
{
public:
/// The class name.
string className() const { return "eoBinCrossover"; }
string className() const { return "eo1PtBitXover"; }
/**
* 1-point crossover for binary chromosomes.
@ -274,7 +274,7 @@ template<class Chrom> class eoBinCrossover: public eoQuadraticOp<Chrom>
*/
void operator()(Chrom& chrom1, Chrom& chrom2)
{
unsigned site = rng.random(min(chrom1.size(), chrom2.size()));
unsigned site = eo::rng.random(min(chrom1.size(), chrom2.size()));
if (!std::equal(chrom1.begin(), chrom1.begin()+site, chrom2.begin()))
{
@ -288,22 +288,22 @@ template<class Chrom> class eoBinCrossover: public eoQuadraticOp<Chrom>
};
/** eoBinUxOver --> classic Uniform crossover
\class eoBinNxOver eoBitOp.h ga/eoBitOp.h
/** eoUBitXover --> classic Uniform crossover
\class eoUBitXover eoBitOp.h ga/eoBitOp.h
\ingroup bitstring
*/
template<class Chrom> class eoBinUxOver: public eoQuadraticOp<Chrom>
template<class Chrom> class eoUBitXover: public eoQuadOp<Chrom>
{
public:
/// (Default) Constructor.
eoBinUxOver(const float& _preference = 0.5): preference(_preference)
eoUBitXover(const float& _preference = 0.5): preference(_preference)
{
if ( (_preference <= 0.0) || (_preference >= 1.0) )
runtime_error("UxOver --> invalid preference");
}
/// The class name.
string className() const { return "eoBinUxOver"; }
string className() const { return "eoUBitXover"; }
/**
* Uniform crossover for binary chromosomes.
@ -318,7 +318,7 @@ template<class Chrom> class eoBinUxOver: public eoQuadraticOp<Chrom>
bool changed = false;
for (unsigned int i=0; i<chrom1.size(); i++)
{
if (rng.flip(preference))
if (eo::rng.flip(preference))
{
bool tmp = chrom1[i];
chrom1[i]=chrom2[i];
@ -337,23 +337,23 @@ template<class Chrom> class eoBinUxOver: public eoQuadraticOp<Chrom>
};
/** eoBinNxOver --> n-point crossover
\class eoBinNxOver eoBitOp.h ga/eoBitOp.h
/** eoNPtsBitXover --> n-point crossover
\class eoNPtsBitXover eoBitOp.h ga/eoBitOp.h
\ingroup bitstring
*/
template<class Chrom> class eoBinNxOver: public eoQuadraticOp<Chrom>
template<class Chrom> class eoNPtsBitXover: public eoQuadOp<Chrom>
{
public:
/// (Default) Constructor.
eoBinNxOver(const unsigned& _num_points = 2): num_points(_num_points)
eoNPtsBitXover(const unsigned& _num_points = 2): num_points(_num_points)
{
if (num_points < 1)
runtime_error("NxOver --> invalid number of points");
}
/// The class name.
string className() const { return "eoBinNxOver"; }
string className() const { return "eoNPtsBitXover"; }
/**
* n-point crossover for binary chromosomes.
@ -369,7 +369,7 @@ template<class Chrom> class eoBinNxOver: public eoQuadraticOp<Chrom>
// select ranges of bits to swap
do {
unsigned bit = rng.random(max_size) + 1;
unsigned bit = eo::rng.random(max_size) + 1;
if (points[bit])
continue;
else
@ -401,16 +401,18 @@ template<class Chrom> class eoBinNxOver: public eoQuadraticOp<Chrom>
/** eoBinGxOver --> gene crossover
\class eoBinGxOver eoBitOp.h ga/eoBitOp.h
/** eoBitGxOver --> Npts crossover when bistring considered
as a string of binary-encoded genes (exchanges genes)
Is anybody still using it apart from historians ??? :-)
\class eoBitGxOver eoBitOp.h ga/eoBitOp.h
\ingroup bitstring
*/
template<class Chrom> class eoBinGxOver: public eoQuadraticOp<Chrom>
template<class Chrom> class eoBitGxOver: public eoQuadOp<Chrom>
{
public:
/// Constructor.
eoBinGxOver(const unsigned _gene_size, const unsigned _num_points = 2):
eoBitGxOver(const unsigned _gene_size, const unsigned _num_points = 2):
gene_size(_gene_size), num_points(_num_points)
{
if (gene_size < 1)
@ -420,7 +422,7 @@ template<class Chrom> class eoBinGxOver: public eoQuadraticOp<Chrom>
}
/// The class name
string className() const { return "eoBinGxOver"; }
string className() const { return "eoBitGxOver"; }
/**
* Gene crossover for binary chromosomes.
@ -436,7 +438,7 @@ template<class Chrom> class eoBinGxOver: public eoQuadraticOp<Chrom>
// selects genes to swap
do {
unsigned bit = rng.random(max_genes);
unsigned bit = eo::rng.random(max_genes);
if (points[bit])
continue;
else

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

@ -26,8 +26,8 @@
#ifndef _EOBITOPFACTORY_H
#define _EOBITOPFACTORY_H
#include <eoOpFactory.h>
#include <eoBitOp.h>
#include <eoFactory.h>
#include <ga/eoBitOp.h>
//-----------------------------------------------------------------------------
@ -36,7 +36,7 @@ on bitstring chromosomes. Only those chromosomes can instantiate the operators
that are created here
@see eoSelect*/
template< class EOT>
class eoBitOpFactory: public eoOpFactory<EOT>
class eoBitOpFactory: public eoFactory<EOT>
{
public:
@ -64,49 +64,97 @@ public:
{
eoOp<EOT> * opPtr = NULL;
try {
opPtr = eoOpFactory<EOT>::make( _is );
opPtr = eoFactory<EOT>::make( _is );
} catch ( const string& objectTypeStr ) {
if ( objectTypeStr == "eoBinRandom") {
opPtr = new eoBinRandom<EOT>();
}
if ( objectTypeStr == "eoBinBitFlip" ) {
opPtr = new eoBinBitFlip<EOT>( );
opPtr = new eoOneBitFlip<EOT>( );
}
// handles old operator names as well as new ones
if ( objectTypeStr == "eoOneBitFlip" ) {
opPtr = new eoOneBitFlip<EOT>( );
}
// Standard BitFilp Mutation
if ( objectTypeStr == "eoBinMutation" ) {
float rate;
_is >> rate;
opPtr = new eoBinMutation<EOT>( rate );
opPtr = new eoBitMutation<EOT>( rate );
}
if ( objectTypeStr == "eoBitMutation" ) {
float rate;
_is >> rate;
opPtr = new eoBitMutation<EOT>( rate );
}
// Bit inversion
if ( objectTypeStr == "eoBinInversion" ) {
opPtr = new eoBinInversion<EOT>( );
opPtr = new eoBitInversion<EOT>( );
}
if ( objectTypeStr == "eoBitInversion" ) {
opPtr = new eoBitInversion<EOT>( );
}
// Next binary value
if ( objectTypeStr == "eoBinNext" ) {
opPtr = new eoBinNext<EOT>( );
opPtr = new eoBitNext<EOT>( );
}
if ( objectTypeStr == "eoBitNext" ) {
opPtr = new eoBitNext<EOT>( );
}
// Previous binary value
if ( objectTypeStr == "eoBinPrev" ) {
opPtr = new eoBinPrev<EOT>( );
opPtr = new eoBitPrev<EOT>( );
}
if ( objectTypeStr == "eoBinNext" ) {
opPtr = new eoBinNext<EOT>( );
if ( objectTypeStr == "eoBitPrev" ) {
opPtr = new eoBitPrev<EOT>( );
}
// 1 point Xover
if ( objectTypeStr == "eoBinCrossover" ) {
opPtr = new eoBinCrossover<EOT>( );
opPtr = new eo1PtBitXover<EOT>( );
}
if ( objectTypeStr == "eo1PtBitXover" ) {
opPtr = new eo1PtBitXover<EOT>( );
}
// Npts Xover
if ( objectTypeStr == "eoBinNxOver" ) {
unsigned nPoints;
_is >> nPoints;
opPtr = new eoBinNxOver<EOT>( nPoints );
opPtr = new eoNPtsBitXover<EOT>( nPoints );
}
if ( objectTypeStr == "eoNPtsBitXover" ) {
unsigned nPoints;
_is >> nPoints;
opPtr = new eoNPtsBitXover<EOT>( nPoints );
}
// Gene Xover (obsolete)
if ( objectTypeStr == "eoBinGxOver" ) {
unsigned geneSize, nPoints;
_is >> geneSize >> nPoints;
opPtr = new eoBinGxOver<EOT>( geneSize, nPoints );
opPtr = new eoBitGxOver<EOT>( geneSize, nPoints );
}
if ( objectTypeStr == "eoBitGxOver" ) {
unsigned geneSize, nPoints;
_is >> geneSize >> nPoints;
opPtr = new eoBitGxOver<EOT>( geneSize, nPoints );
}
// Uniform Xover
if ( objectTypeStr == "eoBinUxOver" ) {
float rate;
_is >> rate;
opPtr = new eoBinUxOver<EOT>( rate );
opPtr = new eoUBitXover<EOT>( rate );
}
if ( objectTypeStr == "eoUBitXover" ) {
float rate;
_is >> rate;
opPtr = new eoUBitXover<EOT>( rate );
}
// nothing read!
if ( !opPtr ) { // to be caught by the upper level
throw objectTypeStr;
}

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

@ -5,8 +5,6 @@
#include <EO.h>
#include <eoOp.h>
#include <eoInserter.h>
#include <eoIndiSelector.h>
#include <gp/parse_tree.h>
#include <eoInit.h>
@ -154,47 +152,47 @@ private :
};
template<class FType, class Node>
class eoSubtreeXOver: public eoGeneralOp< eoParseTree<FType, Node> > {
class eoSubtreeXOver: public eoQuadOp< eoParseTree<FType, Node> > {
public:
typedef eoParseTree<FType, Node> EoType;
eoSubtreeXOver( unsigned _max_length)
: eoGeneralOp<EoType>(), max_length(_max_length) {};
: eoQuadOp<EoType>(), max_length(_max_length) {};
virtual string className() const { return "eoSubtreeXOver"; };
/// Dtor
virtual ~eoSubtreeXOver () {};
void operator()(eoIndiSelector<EoType>& _select, eoInserter<EoType>& _insert )
void operator()(EoType & _eo1, EoType & _eo2 )
{
EoType eo1 = _select();
const EoType& eo2 = _select();
int i = rng.random(_eo1.size());
int j = rng.random(_eo2.size());
int i = rng.random(eo1.size());
int j = rng.random(eo2.size());
eo1[i] = eo2[j]; // insert subtree
parse_tree<Node>::subtree tmp = _eo2[j];
_eo1[i] = _eo2[j]; // insert subtree
_eo2[j]=tmp;
eo1.pruneTree(max_length);
_eo1.pruneTree(max_length);
_eo2.pruneTree(max_length);
eo1.invalidate();
_insert(eo1);
_eo1.invalidate();
_eo2.invalidate();
}
unsigned max_length;
};
template<class FType, class Node>
class eoBranchMutation: public eoGeneralOp< eoParseTree<FType, Node> >
class eoBranchMutation: public eoMonOp< eoParseTree<FType, Node> >
{
public:
typedef eoParseTree<FType, Node> EoType;
eoBranchMutation(eoInit<EoType>& _init, unsigned _max_length)
: eoGeneralOp<EoType>(), max_length(_max_length), initializer(_init)
: eoMonOp<EoType>(), max_length(_max_length), initializer(_init)
{};
virtual string className() const { return "eoBranchMutation"; };
@ -202,22 +200,20 @@ public:
/// Dtor
virtual ~eoBranchMutation() {};
void operator()(eoIndiSelector<EoType>& _select, eoInserter<EoType>& _insert )
void operator()(EoType& _eo1 )
{
EoType eo1 = _select();
int i = rng.random(eo1.size());
int i = rng.random(_eo1.size());
EoType eo2;
initializer(eo2);
int j = rng.random(eo2.size());
eo1[i] = eo2[j]; // insert subtree
_eo1[i] = eo2[j]; // insert subtree
eo1.pruneTree(max_length);
_eo1.pruneTree(max_length);
eo1.invalidate();
_insert(eo1);
_eo1.invalidate();
}
private :

0
eo/src/eoBackInserter.h → eo/src/obsolete/eoBackInserter.h
View file

0
eo/src/eoDetTournamentInserter.h → eo/src/obsolete/eoDetTournamentInserter.h
View file

0
eo/src/eoGOpBreeder.h → eo/src/obsolete/eoGOpBreeder.h
View file

0
eo/src/eoGOpSelector.h → eo/src/obsolete/eoGOpSelector.h
View file

0
eo/src/eoIndiSelector.h → eo/src/obsolete/eoIndiSelector.h
View file

0
eo/src/eoInplaceTransform.h → eo/src/obsolete/eoInplaceTransform.h
View file

0
eo/src/eoInserter.h → eo/src/obsolete/eoInserter.h
View file

0
eo/src/eoOpFactory.h → eo/src/obsolete/eoOpFactory.h
View file

0
eo/src/eoOpSelector.h → eo/src/obsolete/eoOpSelector.h
View file

0
eo/src/eoProportionalGOpSel.h → eo/src/obsolete/eoProportionalGOpSel.h
View file

0
eo/src/eoProportionalOpSel.h → eo/src/obsolete/eoProportionalOpSel.h
View file

0
eo/src/eoSequentialGOpSel.h → eo/src/obsolete/eoSequentialGOpSel.h
View file

0
eo/src/eoSteadyStateEA.h → eo/src/obsolete/eoSteadyStateEA.h
View file

0
eo/src/eoSteadyStateInserter.h → eo/src/obsolete/eoSteadyStateInserter.h
View file

0
eo/src/eoSteadyStateTransform.h → eo/src/obsolete/eoSteadyStateTransform.h
View file

0
eo/src/eoStochTournamentInserter.h → eo/src/obsolete/eoStochTournamentInserter.h
View file

0
eo/src/eoWrappedOps.h → eo/src/obsolete/eoWrappedOps.h
View file

4
eo/src/other/eoExternalOpFunctions.h
View file

@ -153,11 +153,11 @@ class eoExternalBinOp : public eoBinOp<ExternalEO>
The function should return true when it changed something, false otherwise
*/
template <class F, class External, class ExternalEO = eoExternalEO<F, External> >
class eoExternalQuadraticOp : public eoQuadraticOp<ExternalEO>
class eoExternalQuadOp : public eoQuadOp<ExternalEO>
{
public :
eoExternalQuadraticOp(bool (*_quadop)(External&, External&)) : quadop(_quadop) {}
eoExternalQuadOp(bool (*_quadop)(External&, External&)) : quadop(_quadop) {}
void operator()(ExternalEO& eo1, ExternalEO& eo2)
{

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

@ -197,7 +197,6 @@ void eoParser::printOn(ostream& os) const
std::string section = p->first;
printSectionHeader(os, section);
//print every param with its value
for (; p != params.end(); ++p)
{