938 lines
31 KiB
Smarty
938 lines
31 KiB
Smarty
\TEMPLATE_START// -*- mode: c++; c-indent-level: 2; c++-member-init-indent: 8; comment-column: 35; -*-
|
|
//
|
|
// (The above line is useful in Emacs-like editors)
|
|
//
|
|
//*************************************
|
|
//
|
|
// EASEA.cpp
|
|
//
|
|
// C++ file generated by AESAE-EO v0.7
|
|
//
|
|
//*************************************
|
|
//
|
|
//
|
|
// Main file for creating a new representation in EO
|
|
// =================================================
|
|
//
|
|
// This main file includes all other files that have been generated by the
|
|
// script create.sh, so it is the only file to compile.
|
|
//
|
|
// In case you want to build up a separate library for your new Evolving Object,
|
|
// you'll need some work - follow what's done in the src/ga dir, used in the
|
|
// main file BitEA in tutorial/Lesson4 dir.
|
|
// Or you can wait until we do it :-)
|
|
|
|
// Miscellany includes and declarations
|
|
#include <iostream>
|
|
using namespace std;
|
|
|
|
// eo general include
|
|
#include "eo"
|
|
// real bounds (not yet in general eo include)
|
|
#include "utils/eoRealVectorBounds.h"
|
|
|
|
unsigned *pCurrentGeneration;
|
|
unsigned *pEZ_NB_GEN;
|
|
double EZ_MUT_PROB, EZ_XOVER_PROB, EZ_REPL_PERC=0.0;
|
|
int EZ_NB_GEN, EZ_POP_SIZE;
|
|
unsigned long EZ_NB_EVALUATIONS=0L;
|
|
|
|
inline int random(int b1=0, int b2=1){
|
|
return rng.random(b2-b1)+b1;
|
|
}
|
|
inline double random(double b1=0, double b2=1){
|
|
return rng.uniform(b2-b1)+b1;
|
|
}
|
|
inline float random(float b1=0, float b2=1){
|
|
return rng.uniform(b2-b1)+b1;
|
|
}
|
|
|
|
\ANALYSE_PARAMETERS
|
|
\INSERT_USER_DECLARATIONS
|
|
\INSERT_INITIALISATION_FUNCTION
|
|
|
|
// include here whatever specific files for your representation
|
|
// Basically, this should include at least the following
|
|
|
|
/** definition of representation:
|
|
* class EASEAGenome MUST derive from EO<FitT> for some fitness
|
|
*/
|
|
#include "EASEAGenome.h"
|
|
|
|
// GENOTYPE EASEAGenome ***MUST*** be templatized over the fitness
|
|
|
|
//*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*
|
|
// START fitness type: double or eoMaximizingFitness if you are maximizing
|
|
// eoMinimizingFitness if you are minimizing
|
|
typedef \MINIMAXI MyFitT ; // type of fitness
|
|
// END fitness type
|
|
//*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*
|
|
|
|
// Then define your EO objects using that fitness type
|
|
typedef EASEAGenome<MyFitT> Indi; // ***MUST*** derive from EO
|
|
|
|
\INSERT_USER_FUNCTIONS
|
|
|
|
/** definition of evaluation:
|
|
* class EASEAEvalFunc MUST derive from eoEvalFunc<EASEAGenome>
|
|
* and should test for validity before doing any computation
|
|
* see tutorial/Templates/evalFunc.tmpl
|
|
*/
|
|
#include "EASEAEvalFunc.h"
|
|
|
|
/** definition of initialization:
|
|
* class EASEAGenomeInit MUST derive from eoInit<EASEAGenome>
|
|
*/
|
|
#include "EASEAInit.h"
|
|
|
|
/** include all files defining variation operator classes
|
|
*/
|
|
#include "EASEAMutation.h"
|
|
#include "EASEAQuadCrossover.h"
|
|
|
|
// Use existing modules to define representation independent routines
|
|
// These are parser-based definitions of objects
|
|
|
|
// how to initialize the population
|
|
// it IS representation independent if an eoInit is given
|
|
#include <do/make_pop.h>
|
|
eoPop<Indi >& make_pop(eoParser& _parser, eoState& _state, eoInit<Indi> & _init){
|
|
return do_make_pop(_parser, _state, _init);
|
|
}
|
|
|
|
// the stopping criterion
|
|
#include "do/make_continue.h"
|
|
eoContinue<Indi>& make_continue(eoParser& _parser, eoState& _state, eoEvalFuncCounter<Indi> & _eval){
|
|
return do_make_continue(_parser, _state, _eval);
|
|
}
|
|
|
|
// outputs (stats, population dumps, ...)
|
|
#include <do/make_checkpoint.h>
|
|
eoCheckPoint<Indi>& make_checkpoint(eoParser& _parser, eoState& _state, eoEvalFuncCounter<Indi>& _eval, eoContinue<Indi>& _continue) {
|
|
return do_make_checkpoint(_parser, _state, _eval, _continue);
|
|
}
|
|
|
|
// evolution engine (selection and replacement)
|
|
#include <do/make_algo_easea.h>
|
|
eoAlgo<Indi>& make_algo_scalar(eoParser& _parser, eoState& _state, eoEvalFunc<Indi>& _eval, eoContinue<Indi>& _continue, eoGenOp<Indi>& _op){
|
|
return do_make_algo_scalar(_parser, _state, _eval, _continue, _op);
|
|
}
|
|
|
|
// simple call to the algo. stays there for consistency reasons
|
|
// no template for that one
|
|
#include <do/make_run.h>
|
|
// the instanciating fitnesses
|
|
#include <eoScalarFitness.h>
|
|
void run_ea(eoAlgo<Indi>& _ga, eoPop<Indi>& _pop){
|
|
do_run(_ga, _pop);
|
|
}
|
|
|
|
// checks for help demand, and writes the status file
|
|
// and make_help; in libutils
|
|
void make_help(eoParser & _parser);
|
|
|
|
// now use all of the above, + representation dependent things
|
|
int main(int argc, char* argv[]){
|
|
|
|
try {
|
|
\INSERT_INIT_FCT_CALL
|
|
|
|
eoParser parser(argc, argv); // for user-parameter reading
|
|
|
|
eoState state; // keeps all things allocated
|
|
|
|
// The fitness
|
|
//////////////
|
|
EASEAEvalFunc<Indi> plainEval/* (varType _anyVariable) */;
|
|
// turn that object into an evaluation counter
|
|
eoEvalFuncCounter<Indi> eval(plainEval);
|
|
|
|
// a genotype initializer
|
|
EASEAInit<Indi> init;
|
|
// or, if you need some parameters, you might as well
|
|
// - write a constructor of the eoMyStructInit that uses a parser
|
|
// - call it from here:
|
|
// eoEASEAInit<Indi> init(parser);
|
|
|
|
|
|
// Build the variation operator (any seq/prop construct)
|
|
// here, a simple example with only 1 crossover (2->2, a QuadOp) and
|
|
// one mutation, is given.
|
|
// Hints to have choice among multiple crossovers and mutations are given
|
|
|
|
// A (first) crossover (possibly use the parser in its Ctor)
|
|
EASEAQuadCrossover<Indi> cross /* (eoParser parser) */;
|
|
|
|
// IF MORE THAN ONE:
|
|
|
|
// read its relative rate in the combination
|
|
// double cross1Rate = parser.createParam(1.0, "cross1Rate", "Relative rate for crossover 1", '1', "Variation Operators").value();
|
|
|
|
// create the combined operator with the first one (rename it cross1 !!!)
|
|
// eoPropCombinedQuadOp<Indi> cross(cross1, cross1Rate);
|
|
|
|
// and as many as you want the following way:
|
|
// 1- write the new class by mimicking eoEASEAQuadCrossover.h
|
|
// 2- include that file here together with eoEASEAQuadCrossover above
|
|
// 3- uncomment and duplicate the following lines:
|
|
//
|
|
// eoEASEASecondCrossover<Indi> cross2(eoParser parser);
|
|
// double cross2Rate = parser.createParam(1.0, "cross2Rate", "Relative rate for crossover 2", '2', "Variation Operators").value();
|
|
// cross.add(cross2, cross2Rate);
|
|
|
|
// NOTE: if you want some gentle output, the last one shoudl be like
|
|
// cross.add(cross, crossXXXRate, true);
|
|
|
|
/////////////// Same thing for MUTATION
|
|
|
|
// a (first) mutation (possibly use the parser in its Ctor)
|
|
EASEAMutation<Indi> mut /* (eoParser parser) */;
|
|
|
|
// IF MORE THAN ONE:
|
|
|
|
// read its relative rate in the combination
|
|
// double mut1Rate = parser.createParam(1.0, "mut1Rate", "Relative rate for mutation 1", '1', "Variation Operators").value();
|
|
|
|
// create the combined operator with the first one (rename it cross1 !!!)
|
|
// eoPropCombinedMonOp<Indi> mut(mut1, mut1Rate);
|
|
|
|
// and as many as you want the following way:
|
|
// 1- write the new class by mimicking eoEASEAMutation.h
|
|
// 2- include that file here together with eoEASEAMutation above
|
|
// 3- uncomment and duplicate the following lines:
|
|
//
|
|
// eoEASEASecondMutation<Indi> mut2(eoParser parser);
|
|
// double mut2Rate = parser.createParam(1.0, "mut2Rate", "Relative rate for mutation 2", '2', "Variation Operators").value();
|
|
// mut.add(mut2, mut2Rate);
|
|
|
|
// NOTE: if you want some gentle output, the last one shoudl be like
|
|
// mut.add(mut, mutXXXRate, true);
|
|
|
|
// now encapsulate your crossover(s) and mutation(s) into an eoGeneralOp
|
|
// so you can fully benefit of the existing evolution engines
|
|
|
|
// First read the individual level parameters
|
|
double pCross = parser.createParam(0.6, "pCross", "Probability of Crossover", 'C', "Variation Operators" ).value();
|
|
// minimum check
|
|
if ( (pCross < 0) || (pCross > 1) )
|
|
throw runtime_error("Invalid pCross");
|
|
|
|
double pMut = parser.createParam(0.1, "pMut", "Probability of Mutation", 'M', "Variation Operators" ).value();
|
|
// minimum check
|
|
if ( (pMut < 0) || (pMut > 1) )
|
|
throw runtime_error("Invalid pMut");
|
|
|
|
// now create the generalOp
|
|
eoSGAGenOp<Indi> op(cross, pCross, mut, pMut);
|
|
|
|
|
|
|
|
//// Now the representation-independent things
|
|
//
|
|
// YOU SHOULD NOT NEED TO MODIFY ANYTHING BEYOND THIS POINT
|
|
// unless you want to add specific statistics to the checkpoint
|
|
//////////////////////////////////////////////
|
|
|
|
// initialize the population
|
|
// yes, this is representation indepedent once you have an eoInit
|
|
eoPop<Indi>& pop = make_pop(parser, state, init);
|
|
// give popSize to AESAE control
|
|
EZ_POP_SIZE = pop.size();
|
|
|
|
// stopping criteria
|
|
eoContinue<Indi> & term = make_continue(parser, state, eval);
|
|
// output
|
|
eoCheckPoint<Indi> & checkpoint = make_checkpoint(parser, state, eval, term);
|
|
// algorithm (need the operator!)
|
|
eoAlgo<Indi>& ga = make_algo_scalar(parser, state, eval, checkpoint, op);
|
|
|
|
///// End of construction of the algorithm
|
|
|
|
/////////////////////////////////////////
|
|
// to be called AFTER all parameters have been read!!!
|
|
make_help(parser);
|
|
|
|
//// GO
|
|
///////
|
|
// evaluate intial population AFTER help and status in case it takes time
|
|
apply<Indi>(eval, pop);
|
|
// if you want to print it out
|
|
// cout << "Initial Population\n";
|
|
// pop.sortedPrintOn(cout);
|
|
// cout << endl;
|
|
|
|
run_ea(ga, pop); // run the ga
|
|
|
|
cout << "Best individual in final population\n";
|
|
cout << pop.best_element() << endl;
|
|
|
|
}
|
|
catch(exception& e)
|
|
{
|
|
cout << e.what() << endl;
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
\START_EO_GENOME_H_TPL// -*- mode: c++; c-indent-level: 2; c++-member-init-indent: 8; comment-column: 35; -*-
|
|
//
|
|
// (The above line is useful in Emacs-like editors)
|
|
//
|
|
//*************************************
|
|
//
|
|
// EASEAGenome.h
|
|
//
|
|
// C++ file generated by AESAE-EO v0.7
|
|
//
|
|
//*************************************
|
|
//
|
|
|
|
#ifndef _EASEAGenome_h
|
|
#define _EASEAGenome_h
|
|
|
|
/**
|
|
* Always write a comment in this format before class definition
|
|
* if you want the class to be documented by Doxygen
|
|
|
|
* Note that you MUST derive your structure from EO<fitT>
|
|
* but you MAY use some other already prepared class in the hierarchy
|
|
* like eoVector for instance, if you handle a vector of something....
|
|
|
|
* If you create a structure from scratch,
|
|
* the only thing you need to provide are
|
|
* a default constructor
|
|
* IO routines printOn and readFrom
|
|
*
|
|
* Note that operator<< and operator>> are defined at EO level
|
|
* using these routines
|
|
*/
|
|
\ANALYSE_USER_CLASSES
|
|
\INSERT_USER_CLASSES
|
|
|
|
template< class FitT>
|
|
class EASEAGenome: public EO<FitT> {
|
|
public:
|
|
/** Ctor: you MUST provide a default ctor.
|
|
* though such individuals will generally be processed
|
|
* by some eoInit object
|
|
*/
|
|
EASEAGenome() : EO<FitT>()
|
|
{
|
|
// START Code of default Ctor of an EASEAGenome object
|
|
\GENOME_CTOR
|
|
// END Code of default Ctor of an EASEAGenome object
|
|
}
|
|
|
|
EASEAGenome(const EASEAGenome & arg) : EO<FitT>()
|
|
{
|
|
\GENOME_CTOR
|
|
copy(arg);
|
|
}
|
|
|
|
virtual ~EASEAGenome()
|
|
{
|
|
// START Code of Destructor of an EASEAGenome object
|
|
\GENOME_DTOR
|
|
// END Code of Destructor of an EASEAGenome object
|
|
}
|
|
|
|
virtual string className() const { return "EASEAGenome"; }
|
|
|
|
EASEAGenome& operator=(const EASEAGenome & arg) {
|
|
copy(arg);
|
|
return *this;
|
|
}
|
|
|
|
void copy(const EASEAGenome& genome)
|
|
{
|
|
if(&genome != this){
|
|
\GENOME_DTOR
|
|
\COPY_CTOR
|
|
if (genome.invalid()) { // copying an invalid genome
|
|
fitness(FitT()); // put a valid value (i.e. non NAN)
|
|
invalidate(); // but INVALIDATE the genome
|
|
}
|
|
else
|
|
fitness(genome.fitness());
|
|
}
|
|
}
|
|
|
|
bool operator==(const EASEAGenome & genome) const {
|
|
\EQUAL
|
|
return true;
|
|
}
|
|
|
|
bool operator!=(const EASEAGenome & genome) const {
|
|
return !(*this==genome);
|
|
}
|
|
|
|
/** printing... */
|
|
void printOn(ostream& os) const
|
|
{
|
|
// First write the fitness
|
|
EO<FitT>::printOn(os);
|
|
os << ' ';
|
|
// START Code of default output
|
|
|
|
/** HINTS
|
|
* in EO we systematically write the sizes of things before the things
|
|
* so readFrom is easier to code (see below)
|
|
*/
|
|
\INSERT_DISPLAY
|
|
\WRITE
|
|
// END Code of default output
|
|
}
|
|
|
|
/** reading...
|
|
* of course, your readFrom must be able to read what printOn writes!!!
|
|
*/
|
|
void readFrom(istream& is)
|
|
{
|
|
// of course you should read the fitness first!
|
|
EO<FitT>::readFrom(is);
|
|
// START Code of input
|
|
|
|
/** HINTS
|
|
* remember the EASEAGenome object will come from the default ctor
|
|
* this is why having the sizes written out is useful
|
|
*/
|
|
\READ
|
|
// END Code of input
|
|
}
|
|
|
|
//private: // put all data here - no privacy in EASEA
|
|
// START Private data of an EASEAGenome object
|
|
\INSERT_GENOME
|
|
// END Private data of an EASEAGenome object
|
|
};
|
|
#endif
|
|
|
|
\START_EO_EVAL_TPL// -*- mode: c++; c-indent-level: 2; c++-member-init-indent: 8; comment-column: 35; -*-
|
|
//
|
|
// (The above line is useful in Emacs-like editors)
|
|
//
|
|
//*************************************
|
|
//
|
|
// EASEAEvalFunc.h
|
|
//
|
|
// C++ file generated by AESAE-EO v0.7
|
|
//
|
|
//*************************************
|
|
//
|
|
|
|
/*
|
|
Evaluator in EO: a functor that computes the fitness of an EO
|
|
=============================================================
|
|
*/
|
|
|
|
#ifndef _EASEAEvalFunc_h
|
|
#define _EASEAEvalFunc_h
|
|
|
|
// include whatever general include you need
|
|
#include <stdexcept>
|
|
#include <fstream>
|
|
|
|
// include the base definition of eoEvalFunc
|
|
#include "eoEvalFunc.h"
|
|
|
|
/**
|
|
Always write a comment in this format before class definition
|
|
if you want the class to be documented by Doxygen
|
|
*/
|
|
template <class EOT>
|
|
class EASEAEvalFunc : public eoEvalFunc<EOT>
|
|
{
|
|
public:
|
|
/// Ctor - no requirement
|
|
// START eventually add or modify the anyVariable argument
|
|
EASEAEvalFunc()
|
|
// EASEAEvalFunc( varType _anyVariable) : anyVariable(_anyVariable)
|
|
// END eventually add or modify the anyVariable argument
|
|
{
|
|
// START Code of Ctor of an EASEAEvalFunc object
|
|
// END Code of Ctor of an EASEAEvalFunc object
|
|
}
|
|
|
|
/** Actually compute the fitness
|
|
*
|
|
* @param EOT & _eo the EO object to evaluate
|
|
* it should stay templatized to be usable
|
|
* with any fitness type
|
|
*/
|
|
void operator()(EOT & genome)
|
|
{
|
|
// test for invalid to avoid recomputing fitness of unmodified individuals
|
|
if (genome.invalid())
|
|
{
|
|
// START Code of computation of fitness of the EASEA object
|
|
\INSERT_EVALUATOR
|
|
// END Code of computation of fitness of the EASEA object
|
|
}
|
|
}
|
|
|
|
private:
|
|
// START Private data of an EASEAEvalFunc object
|
|
// varType anyVariable; // for example ...
|
|
// END Private data of an EASEAEvalFunc object
|
|
};
|
|
|
|
|
|
#endif
|
|
|
|
\START_EO_INITER_TPL// -*- mode: c++; c-indent-level: 2; c++-member-init-indent: 8; comment-column: 35; -*-
|
|
//
|
|
// (The above line is useful in Emacs-like editors)
|
|
//
|
|
//*************************************
|
|
//
|
|
// EASEAInit.h
|
|
//
|
|
// C++ file generated by AESAE-EO v0.7
|
|
//
|
|
//*************************************
|
|
//
|
|
|
|
/*
|
|
objects initialization in EO
|
|
============================
|
|
*/
|
|
|
|
#ifndef _EASEAInit_h
|
|
#define _EASEAInit_h
|
|
|
|
// include the base definition of eoInit
|
|
#include <eoInit.h>
|
|
|
|
/**
|
|
* Always write a comment in this format before class definition
|
|
* if you want the class to be documented by Doxygen
|
|
*
|
|
* There is NO ASSUMPTION on the class GenoypeT.
|
|
* In particular, it does not need to derive from EO (e.g. to initialize
|
|
* atoms of an eoVector you will need an eoInit<AtomType>)
|
|
*/
|
|
template <class GenotypeT>
|
|
class EASEAInit: public eoInit<GenotypeT> {
|
|
public:
|
|
/// Ctor - no requirement
|
|
// START eventually add or modify the anyVariable argument
|
|
EASEAInit()
|
|
// EASEAInit( varType & _anyVariable) : anyVariable(_anyVariable)
|
|
// END eventually add or modify the anyVariable argument
|
|
{
|
|
// START Code of Ctor of an EASEAInit object
|
|
// END Code of Ctor of an EASEAInit object
|
|
}
|
|
|
|
|
|
/** initialize a genotype
|
|
*
|
|
* @param _genotype generally a genotype that has been default-constructed
|
|
* whatever it contains will be lost
|
|
*/
|
|
void operator()(GenotypeT & _genotype)
|
|
{
|
|
// START Code of random initialization of an EASEAGenome object
|
|
\INSERT_EO_INITIALISER
|
|
// END Code of random initialization of an EASEAGenome object
|
|
_genotype.invalidate(); // IMPORTANT in case the _genotype is old
|
|
}
|
|
|
|
private:
|
|
// START Private data of an EASEAInit object
|
|
// varType & anyVariable; // for example ...
|
|
// END Private data of an EASEAInit object
|
|
};
|
|
|
|
#endif
|
|
|
|
|
|
\START_EO_MUT_TPL// -*- mode: c++; c-indent-level: 2; c++-member-init-indent: 8; comment-column: 35; -*-
|
|
//
|
|
// (The above line is useful in Emacs-like editors)
|
|
//
|
|
//*************************************
|
|
//
|
|
// EASEAMutation.h
|
|
//
|
|
// C++ file generated by AESAE-EO v0.7
|
|
//
|
|
//*************************************
|
|
//
|
|
|
|
/*
|
|
simple mutation operators
|
|
=========================
|
|
*/
|
|
|
|
#ifndef EASEAMutation_H
|
|
#define EASEAMutation_H
|
|
|
|
|
|
#include <eoOp.h>
|
|
|
|
/**
|
|
* Always write a comment in this format before class definition
|
|
* if you want the class to be documented by Doxygen
|
|
*
|
|
* THere is NO ASSUMPTION on the class GenoypeT.
|
|
* In particular, it does not need to derive from EO
|
|
*/
|
|
template<class GenotypeT>
|
|
class EASEAMutation: public eoMonOp<GenotypeT>
|
|
{
|
|
public:
|
|
/**
|
|
* Ctor - no requirement
|
|
*/
|
|
// START eventually add or modify the anyVariable argument
|
|
EASEAMutation()
|
|
// EASEAMutation( varType _anyVariable) : anyVariable(_anyVariable)
|
|
// END eventually add or modify the anyVariable argument
|
|
{
|
|
// START Code of Ctor of an EASEAMutation object
|
|
// END Code of Ctor of an EASEAMutation object
|
|
}
|
|
|
|
/// The class name. Used to display statistics
|
|
string className() const { return "EASEAMutation"; }
|
|
|
|
/**
|
|
* modifies the parent
|
|
* @param _genotype The parent genotype (will be modified)
|
|
*/
|
|
bool operator()(GenotypeT & _genotype)
|
|
{
|
|
// START code for mutation of the _genotype object
|
|
\INSERT_MUTATOR
|
|
// END code for mutation of the _genotype object
|
|
|
|
private:
|
|
// START Private data of an EASEAMutation object
|
|
// varType anyVariable; // for example ...
|
|
// END Private data of an EASEAMutation object
|
|
};
|
|
|
|
#endif
|
|
|
|
\START_EO_QUAD_XOVER_TPL// -*- mode: c++; c-indent-level: 2; c++-member-init-indent: 8; comment-column: 35; -*-
|
|
//
|
|
// (The above line is useful in Emacs-like editors)
|
|
//
|
|
//*************************************
|
|
//
|
|
// EASEAQuadCrossover.h
|
|
//
|
|
// C++ file generated by AESAE-EO v0.7
|
|
//
|
|
//*************************************
|
|
//
|
|
|
|
/*
|
|
Template for simple quadratic crossover operators
|
|
=================================================
|
|
|
|
Quadratic crossover operators modify both genotypes
|
|
*/
|
|
|
|
#ifndef EASEAQuadCrossover_H
|
|
#define EASEAQuadCrossover_H
|
|
|
|
#include <eoOp.h>
|
|
|
|
/**
|
|
* Always write a comment in this format before class definition
|
|
* if you want the class to be documented by Doxygen
|
|
*
|
|
* THere is NO ASSUMPTION on the class GenoypeT.
|
|
* In particular, it does not need to derive from EO
|
|
*/
|
|
template<class GenotypeT>
|
|
class EASEAQuadCrossover: public eoQuadOp<GenotypeT>
|
|
{
|
|
public:
|
|
/**
|
|
* Ctor - no requirement
|
|
*/
|
|
// START eventually add or modify the anyVariable argument
|
|
EASEAQuadCrossover()
|
|
// EASEAQuadCrossover( varType _anyVariable) : anyVariable(_anyVariable)
|
|
// END eventually add or modify the anyVariable argument
|
|
{
|
|
// START Code of Ctor of an EASEAQuadCrossover object
|
|
// END Code of Ctor of an EASEAQuadCrossover object
|
|
}
|
|
|
|
/// The class name. Used to display statistics
|
|
string className() const { return "EASEAQuadCrossover"; }
|
|
|
|
/**
|
|
* eoQuad crossover - modifies both genotypes
|
|
*/
|
|
bool operator()(GenotypeT& child1, GenotypeT & child2)
|
|
{
|
|
GenotypeT parent1(child1);
|
|
GenotypeT parent2(child2);
|
|
|
|
// START code for crossover of child1 and child2 objects
|
|
\INSERT_CROSSOVER
|
|
return (parent1!=child1)||(parent2!=child2);
|
|
// END code for crossover of child1 and child2 objects
|
|
}
|
|
|
|
private:
|
|
// START Private data of an EASEAQuadCrossover object
|
|
// varType anyVariable; // for example ...
|
|
// END Private data of an EASEAQuadCrossover object
|
|
};
|
|
|
|
#endif
|
|
|
|
\START_EO_CONTINUE_TPL// -*- mode: c++; c-indent-level: 2; c++-member-init-indent: 8; comment-column: 35; -*-
|
|
//
|
|
// (The above line is useful in Emacs-like editors)
|
|
//
|
|
//*************************************
|
|
//
|
|
// EASEA_make_continue.h
|
|
//
|
|
// C++ file generated by AESAE-EO v0.7
|
|
//
|
|
//*************************************
|
|
//
|
|
|
|
#ifndef _make_continue_h
|
|
#define _make_continue_h
|
|
|
|
/*
|
|
Contains the templatized version of parser-based choice of stopping criterion
|
|
It can then be instantiated, and compiled on its own for a given EOType
|
|
(see e.g. in dir ga, ga.cpp)
|
|
*/
|
|
|
|
// Continuators - all include eoContinue.h
|
|
#include <eoCombinedContinue.h>
|
|
#include <eoGenContinue.h>
|
|
#include <eoSteadyFitContinue.h>
|
|
#include <eoEvalContinue.h>
|
|
#include <eoFitContinue.h>
|
|
#ifndef _MSC_VER
|
|
#include <eoCtrlCContinue.h> // CtrlC handling (using 2 global variables!)
|
|
#endif
|
|
|
|
// also need the parser and param includes
|
|
#include <utils/eoParser.h>
|
|
#include <utils/eoState.h>
|
|
|
|
|
|
/////////////////// the stopping criterion ////////////////
|
|
template <class Indi>
|
|
eoCombinedContinue<Indi> * make_combinedContinue(eoCombinedContinue<Indi> *_combined, eoContinue<Indi> *_cont)
|
|
{
|
|
if (_combined) // already exists
|
|
_combined->add(*_cont);
|
|
else
|
|
_combined = new eoCombinedContinue<Indi>(*_cont);
|
|
return _combined;
|
|
}
|
|
|
|
template <class Indi>
|
|
eoContinue<Indi> & do_make_continue(eoParser& _parser, eoState& _state, eoEvalFuncCounter<Indi> & _eval)
|
|
{
|
|
//////////// Stopping criterion ///////////////////
|
|
// the combined continue - to be filled
|
|
eoCombinedContinue<Indi> *continuator = NULL;
|
|
|
|
// for each possible criterion, check if wanted, otherwise do nothing
|
|
|
|
// First the eoGenContinue - need a default value so you can run blind
|
|
// but we also need to be able to avoid it <--> 0
|
|
eoValueParam<unsigned>& maxGenParam = _parser.createParam(\NB_GEN, "maxGen", "Maximum number of generations () = none)",'G',"Stopping criterion");
|
|
// and give control to EASEA
|
|
EZ_NB_GEN = maxGenParam.value();
|
|
pEZ_NB_GEN = & maxGenParam.value();
|
|
|
|
// do not test for positivity in EASEA
|
|
// if (maxGenParam.value()) // positive: -> define and store
|
|
// {
|
|
eoGenContinue<Indi> *genCont = new eoGenContinue<Indi>(maxGenParam.value());
|
|
_state.storeFunctor(genCont);
|
|
// and "add" to combined
|
|
continuator = make_combinedContinue<Indi>(continuator, genCont);
|
|
// }
|
|
|
|
// the steadyGen continue - only if user imput
|
|
eoValueParam<unsigned>& steadyGenParam = _parser.createParam(unsigned(100), "steadyGen", "Number of generations with no improvement",'s', "Stopping criterion");
|
|
eoValueParam<unsigned>& minGenParam = _parser.createParam(unsigned(0), "minGen", "Minimum number of generations",'g', "Stopping criterion");
|
|
if (_parser.isItThere(steadyGenParam))
|
|
{
|
|
eoSteadyFitContinue<Indi> *steadyCont = new eoSteadyFitContinue<Indi>
|
|
(minGenParam.value(), steadyGenParam.value());
|
|
// store
|
|
_state.storeFunctor(steadyCont);
|
|
// add to combinedContinue
|
|
continuator = make_combinedContinue<Indi>(continuator, steadyCont);
|
|
}
|
|
|
|
// Same thing with Eval - but here default value is 0
|
|
eoValueParam<unsigned long>& maxEvalParam = _parser.createParam((unsigned long)0, "maxEval", "Maximum number of evaluations (0 = none)",'E',"Stopping criterion");
|
|
|
|
if (maxEvalParam.value()) // positive: -> define and store
|
|
{
|
|
eoEvalContinue<Indi> *evalCont = new eoEvalContinue<Indi>(_eval, maxEvalParam.value());
|
|
_state.storeFunctor(evalCont);
|
|
// and "add" to combined
|
|
continuator = make_combinedContinue<Indi>(continuator, evalCont);
|
|
}
|
|
/*
|
|
// the steadyEval continue - only if user imput
|
|
eoValueParam<unsigned>& steadyGenParam = _parser.createParam(unsigned(100), "steadyGen", "Number of generations with no improvement",'s', "Stopping criterion");
|
|
eoValueParam<unsigned>& minGenParam = _parser.createParam(unsigned(0), "minGen", "Minimum number of generations",'g', "Stopping criterion");
|
|
if (_parser.isItThere(steadyGenParam))
|
|
{
|
|
eoSteadyGenContinue<Indi> *steadyCont = new eoSteadyFitContinue<Indi>
|
|
(minGenParam.value(), steadyGenParam.value());
|
|
// store
|
|
_state.storeFunctor(steadyCont);
|
|
// add to combinedContinue
|
|
continuator = make_combinedContinue<Indi>(continuator, steadyCont);
|
|
}
|
|
*/
|
|
// the target fitness
|
|
eoFitContinue<Indi> *fitCont;
|
|
eoValueParam<double>& targetFitnessParam = _parser.createParam(double(0.0), "targetFitness", "Stop when fitness reaches",'T', "Stopping criterion");
|
|
if (_parser.isItThere(targetFitnessParam))
|
|
{
|
|
fitCont = new eoFitContinue<Indi>
|
|
(targetFitnessParam.value());
|
|
// store
|
|
_state.storeFunctor(fitCont);
|
|
// add to combinedContinue
|
|
continuator = make_combinedContinue<Indi>(continuator, fitCont);
|
|
}
|
|
|
|
#ifndef _MSC_VER
|
|
// the CtrlC interception (Linux only I'm afraid)
|
|
eoCtrlCContinue<Indi> *ctrlCCont;
|
|
eoValueParam<bool>& ctrlCParam = _parser.createParam(false, "CtrlC", "Terminate current generation upon Ctrl C",'C', "Stopping criterion");
|
|
if (_parser.isItThere(ctrlCParam))
|
|
{
|
|
ctrlCCont = new eoCtrlCContinue<Indi>;
|
|
// store
|
|
_state.storeFunctor(ctrlCCont);
|
|
// add to combinedContinue
|
|
continuator = make_combinedContinue<Indi>(continuator, ctrlCCont);
|
|
}
|
|
#endif
|
|
|
|
// now check that there is at least one!
|
|
if (!continuator)
|
|
throw runtime_error("You MUST provide a stopping criterion");
|
|
// OK, it's there: store in the eoState
|
|
_state.storeFunctor(continuator);
|
|
|
|
// and return
|
|
return *continuator;
|
|
}
|
|
|
|
#endif
|
|
|
|
\START_EO_PARAM_TPL#*************************************
|
|
#
|
|
# EASEA.prm
|
|
#
|
|
# Parameter file generated by AESAE-EO v0.7
|
|
#
|
|
#*************************************
|
|
###### General ######
|
|
# --help=0 # -h : Prints this message
|
|
# --stopOnUnknownParam=1 # Stop if unknown param entered
|
|
--seed=0 # -S : Random number seed
|
|
|
|
###### Evolution Engine ######
|
|
--popSize=\POP_SIZE # -P : Population Size
|
|
--selection=\SELECTOR\SELECT_PRM # -S : Selection: Roulette, Ranking(p,e), DetTour(T), StochTour(t) or Sequential(ordered/unordered)
|
|
--nbOffspring=\OFF_SIZE # -O : Nb of offspring (percentage or absolute)
|
|
--replacement=General # Type of replacement: Generational, ESComma, ESPlus, SSGA(T), EP(T)
|
|
|
|
###### Evolution Engine / Replacement ######
|
|
--elite=\ELITE_SIZE # Nb of elite parents (percentage or absolute)
|
|
--eliteType=\ELITISM # Strong (true) or weak (false) elitism (set elite to 0 for none)
|
|
--surviveParents=\SURV_PAR_SIZE # Nb of surviving parents (percentage or absolute)
|
|
--reduceParents=\RED_PAR\RED_PAR_PRM # Parents reducer: Deterministic, EP(T), DetTour(T), StochTour(t), Uniform
|
|
--surviveOffspring=\SURV_OFF_SIZE # Nb of surviving offspring (percentage or absolute)
|
|
--reduceOffspring=\RED_OFF\RED_OFF_PRM # Offspring reducer: Deterministic, EP(T), DetTour(T), StochTour(t), Uniform
|
|
--reduceFinal=\RED_FINAL\RED_FINAL_PRM # Final reducer: Deterministic, EP(T), DetTour(T), StochTour(t), Uniform
|
|
|
|
###### Output ######
|
|
# --useEval=1 # Use nb of eval. as counter (vs nb of gen.)
|
|
# --useTime=1 # Display time (s) every generation
|
|
# --printBestStat=1 # Print Best/avg/stdev every gen.
|
|
# --printPop=0 # Print sorted pop. every gen.
|
|
|
|
###### Output - Disk ######
|
|
# --resDir=Res # Directory to store DISK outputs
|
|
# --eraseDir=1 # erase files in dirName if any
|
|
# --fileBestStat=0 # Output bes/avg/std to file
|
|
|
|
###### Output - Graphical ######
|
|
# --plotBestStat=0 # Plot Best/avg Stat
|
|
# --plotHisto=0 # Plot histogram of fitnesses
|
|
|
|
###### Persistence ######
|
|
# --Load= # -L : A save file to restart from
|
|
# --recomputeFitness=0 # -r : Recompute the fitness after re-loading the pop.?
|
|
# --saveFrequency=0 # Save every F generation (0 = only final state, absent = never)
|
|
# --saveTimeInterval=0 # Save every T seconds (0 or absent = never)
|
|
# --status=OneMaxGenomeEA.status # Status file
|
|
|
|
###### Stopping criterion ######
|
|
# --maxGen=100 # -G : Maximum number of generations () = none)
|
|
# --steadyGen=100 # -s : Number of generations with no improvement
|
|
# --minGen=0 # -g : Minimum number of generations
|
|
# --maxEval=0 # -E : Maximum number of evaluations (0 = none)
|
|
# --targetFitness=0 # -T : Stop when fitness reaches
|
|
# --CtrlC=0 # -C : Terminate current generation upon Ctrl C
|
|
|
|
###### Variation Operators ######
|
|
# --cross1Rate=1 # -1 : Relative rate for crossover 1
|
|
# --mut1Rate=1 # -1 : Relative rate for mutation 1
|
|
--pCross=\XOVER_PROB # -C : Probability of Crossover
|
|
--pMut=\MUT_PROB # -M : Probability of Mutation
|
|
|
|
\START_EO_MAKEFILE_TPL#*************************************
|
|
#
|
|
# EASEA.mak
|
|
#
|
|
# Makefile generated by AESAE-EO v0.7
|
|
#
|
|
#*************************************
|
|
|
|
# sample makefile for building an EA evolving a new genotype
|
|
|
|
DIR_EO = \EO_DIR
|
|
|
|
.cpp: ; c++ -DPACKAGE=\"eo\" -I. -I$(DIR_EO)/src -Wall -g -o $@ $*.cpp $(DIR_EO)/src/libeo.a $(DIR_EO)/src/utils/libeoutils.a
|
|
|
|
.cpp.o: ; c++ -DPACKAGE=\"eo\" -I. -I\EO_DIR/src -Wall -g -c $*.cpp
|
|
|
|
LIB_EO = $(DIR_EO)/src/utils/libeoutils.a $(DIR_EO)/src/libeo.a
|
|
|
|
SOURCES = EASEA.cpp \
|
|
EASEAEvalFunc.h \
|
|
EASEAGenome.h \
|
|
EASEAInit.h \
|
|
EASEAMutation.h \
|
|
EASEAQuadCrossover.h \
|
|
$(LIB_EO)
|
|
|
|
ALL = EASEA
|
|
|
|
EASEA : $(SOURCES)
|
|
c++ -g -I. -I$(DIR_EO)/src -o $@ EASEA.cpp $(LIB_EO) -lm
|
|
|
|
all : $(ALL)
|
|
|
|
clean : ; /bin/rm *.o $(ALL)
|
|
|
|
\TEMPLATE_END
|