Back to Lesson 5 - Tutorial main page - Top-Down page - Bottom-up page - Programming hints - EO documentation

# Templates/make_op_OneMax.h

The places where you have to put some code are on pink background.. Only the the character colors have the usual meaning.

`// -*- mode: c++; c-indent-level: 4; c++-member-init-indent: 8; comment-column: 35; -*-`

`//-----------------------------------------------------------------------------`
`// make_op_OneMax.h`
`// (c) Marc Schoenauer, Maarten Keijzer and GeNeura Team, 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: todos@geneura.ugr.es, http://geneura.ugr.es`
`Marc.Schoenauer@inria.fr`
`mkeijzer@dhi.dk`
`*/`
`//-----------------------------------------------------------------------------`

`#ifndef _make_op_OneMax_h`
`#define _make_op_OneMax_h`

`// the operators`
`#include <eoOp.h>`
`#include <eoGenOp.h>`
`#include <eoCloneOps.h>`
`#include <eoOpContainer.h>`
`// combinations of simple eoOps (eoMonOp and eoQuadOp)`
`#include <eoProportionalCombinedOp.h>`

`/** definition of mutation:`
`* class eoOneMaxMonop MUST derive from eoMonOp<eoOneMax>`
`*/`
`#include "eoOneMaxMutation.h"`

`/** definition of crossover (either as eoBinOp (2->1) or eoQuadOp (2->2):`
`* class eoOneMaxBinCrossover MUST derive from eoBinOp<eoOneMax>`
`* OR`
`* class eoOneMaxQuadCrossover MUST derive from eoQuadOp<eoOneMax>`
`*/`
`// #include "eoOneMaxBinOp.h"`
`// OR`
`#include "eoOneMaxQuadCrossover.h"`

`// also need the parser and state includes`
`#include <utils/eoParser.h>`
`#include <utils/eoState.h>`

`/////////////////// variation operators ///////////////`
`// canonical (crossover + mutation) only at the moment //`

`/*`
`* This function builds the operators that will be applied to the eoOneMax`
`*`
`* It uses a parser (to get user parameters), a state (to store the memory)`
`* the last parameter is an eoInit: if some operator needs some info`
`* about the genotypes, the init has it all (e.g. bounds, ...)`
`* Simply do`
`* EOT myEO;`
`* _init(myEO);`
`* and myEO is then an ACTUAL object`
`*`
`* As usual, the template is the complete EOT even though only the fitness`
`* is actually templatized here: the following only applies to eoOneMax`
`*/`

`template <class EOT>`
`eoGenOp<EOT> & do_make_op(eoParameterLoader& _parser, eoState& _state, eoInit<EOT>& _init)`
`{`
`// this is a temporary version, while Maarten codes the full tree-structured`
`// general operator input`
`// BTW we must leave that simple version available somehow, as it is the one`
`// that 90% people use!`

`/////////////////////////////`
`// Variation operators`
`////////////////////////////`
`// read crossover and mutations, combine each in a proportional Op`
`// and create the eoGenOp that calls crossover at rate pCross`
`// then mutation with rate pMut`

`// the crossovers`
`/////////////////`

`// here we can have eoQuadOp (2->2) only - no time for the eoBinOp case`

`// you can have more than one - combined in a proportional way`

`// first, define the crossover objects and read their rates from the parser`

`// A first crossover`
`eoQuadOp<Indi> *cross = new eoOneMaxQuadCrossover<Indi> /* (varType _anyVariable) */;`
`// store in the state`
`_state.storeFunctor(cross);`

`// read its relative rate in the combination`
`double cross1Rate = _parser.createParam(1.0, "cross1Rate", "Relative rate for crossover 1", '1', "Variation Operators").value();`

`// and create the combined operator with this one`
`eoPropCombinedQuadOp<Indi> *propXover =`
`new eoPropCombinedQuadOp<Indi>(*cross, cross1Rate);`
`// and of course stor it in the state`
`_state.storeFunctor(propXover);`

`// Optional: A second(and third, and ...) crossover`
`// of course you must create the corresponding classes`
`// and all ***MUST*** derive from eoQuadOp<Indi>`

`/* Uncomment if necessary - and replicate as many time as you need`
`cross = new eoOneMaxSecondCrossover<Indi>(varType _anyVariable);`
`_state.storeFunctor(cross);`
`double cross2Rate = _parser.createParam(1.0, "cross2Rate", "Relative rate for crossover 2", '2', "Variation Operators").value();`
`propXover.add(*cross, cross2Rate);`
`*/`
`// if you want some gentle output, the last one shoudl be like`
`// propXover.add(*cross, crossXXXRate, true);`

`// the mutation: same story`
`////////////////`
`// you can have more than one - combined in a proportional way`

`// for each mutation,`
`// - define the mutator object`
`// - read its rate from the parser`
`// - add it to the proportional combination`

`// a first mutation`
`eoMonOp<Indi> *mut = new eoOneMaxMutation<Indi> /* (varType _anyVariable) */;`
`_state.storeFunctor(mut);`
`// its relative rate in the combination`
`double mut1Rate = _parser.createParam(1.0, "mut1Rate", "Relative rate for mutation 1", '1', "Variation Operators").value();`
`// and the creation of the combined operator with this one`
`eoPropCombinedMonOp<Indi> *propMutation = new eoPropCombinedMonOp<Indi>(*mut, mut1Rate);`
`_state.storeFunctor(propMutation);`

`// Optional: A second(and third, and ...) mutation with their rates`
`// of course you must create the corresponding classes`
`// and all ***MUST*** derive from eoMonOp<Indi>`

`/* Uncomment if necessary - and replicate as many time as you need`
`mut = new eoOneMaxSecondMutation<Indi>(varType _anyVariable);`
`_state.storeFunctor(mut);`
`double mut2Rate = _parser.createParam(1.0, "mut2Rate", "Relative rate for mutation 2", '2', "Variation Operators").value();`
`propMutation.add(*mut, mut2Rate);`
`*/`
`// if you want some gentle output, the last one shoudl be like`
`// propMutation.add(*mut, mutXXXRate, true);`

`// end of crossover and mutation definitions`

`// from now on, you do not need to modify anything`
`// though you CAN add things to the checkpointing (see tutorial)`

`// now build the eoGenOp:`
`// to simulate SGA (crossover with proba pCross + mutation with proba pMut`
`// we must construct`
`// a sequential combination of`
`// with proba 1, a proportional combination of`
`// a QuadCopy and our crossover`
`// with proba pMut, our mutation`

`// but of course you're free to use any smart combination you could think of`
`// especially, if you have to use eoBinOp rather than eoQuad Op youùll have`
`// to modify that part`

`// First read the individual level parameters`
`eoValueParam<double>& pCrossParam = _parser.createParam(0.6, "pCross", "Probability of Crossover", 'C', "Variation Operators" );`
`// minimum check`
`if ( (pCrossParam.value() < 0) || (pCrossParam.value() > 1) )`
`throw runtime_error("Invalid pCross");`

`eoValueParam<double>& pMutParam = _parser.createParam(0.1, "pMut", "Probability of Mutation", 'M', "Variation Operators" );`
`// minimum check`
`if ( (pMutParam.value() < 0) || (pMutParam.value() > 1) )`
`throw runtime_error("Invalid pMut");`

`// the crossover - with probability pCross`
`eoProportionalOp<Indi> * propOp = new eoProportionalOp<Indi> ;`
`_state.storeFunctor(propOp);`
`eoQuadOp<Indi> *ptQuad = new eoQuadCloneOp<Indi>;`
`_state.storeFunctor(ptQuad);`
`propOp->add(*propXover, pCrossParam.value()); // crossover, with proba pcross`
`propOp->add(*ptQuad, 1-pCrossParam.value()); // nothing, with proba 1-pcross`

`// now the sequential`
`eoSequentialOp<Indi> *op = new eoSequentialOp<Indi>;`
`_state.storeFunctor(op);`
`op->add(*propOp, 1.0); // always do combined crossover`
`op->add(*propMutation, pMutParam.value()); // then mutation, with proba pmut`

`// that's it - return a reference`
`return *op;`
`}`

`#endif`

Back to Lesson 5 - Tutorial main page - Top-Down page - Bottom-up page - Programming hints - EO documentation

Last modified: Fri May 3 08:06:20 2002