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

Use getORcreateParam instead of createParam when getting values from

Browse source 
the eoParser.
Update setORcreateParam.
This commit is contained in:
kuepper 2005-09-12 17:53:25 +00:00
commit 438e8ef6d6
9 changed files with 290 additions and 194 deletions
Download patch file Download diff file Expand all files Collapse all files

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

@ -3,7 +3,7 @@
//----------------------------------------------------------------------------- //-----------------------------------------------------------------------------
// make_continue.h // make_continue.h
// (c) Maarten Keijzer, Marc Schoenauer and GeNeura Team, 2000 // (c) Maarten Keijzer, Marc Schoenauer and GeNeura Team, 2000
/* /*
This library is free software; you can redistribute it and/or This library is free software; you can redistribute it and/or
modify it under the terms of the GNU Lesser General Public modify it under the terms of the GNU Lesser General Public
License as published by the Free Software Foundation; either License as published by the Free Software Foundation; either
@ -94,7 +94,10 @@ eoContinue<Indi> & do_make_continue(eoParser& _parser, eoState& _state, eoEvalFu
} }
// Same thing with Eval - but here default value is 0 // 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"); eoValueParam<unsigned long>& maxEvalParam
= _parser.getORcreateParam((unsigned long)0, "maxEval",
"Maximum number of evaluations (0 = none)",
'E', "Stopping criterion");
if (maxEvalParam.value()) // positive: -> define and store if (maxEvalParam.value()) // positive: -> define and store
{ {

39
eo/src/es/eoEsMutationInit.h
View file

@ -3,7 +3,7 @@
//----------------------------------------------------------------------------- //-----------------------------------------------------------------------------
// eoEsMutationInit.h // eoEsMutationInit.h
// (c) GeNeura Team, 1998 - EEAAX 1999 - Maarten Keijzer 2000 // (c) GeNeura Team, 1998 - EEAAX 1999 - Maarten Keijzer 2000
/* /*
This library is free software; you can redistribute it and/or This library is free software; you can redistribute it and/or
modify it under the terms of the GNU Lesser General Public modify it under the terms of the GNU Lesser General Public
License as published by the Free Software Foundation; either License as published by the Free Software Foundation; either
@ -34,11 +34,11 @@
eoESMutationInit. Proxy class that is used for initializing the mutation eoESMutationInit. Proxy class that is used for initializing the mutation
operator. It provides an interface between eoEsMutate and the abstract operator. It provides an interface between eoEsMutate and the abstract
parameterLoader. It also provides the names for the parameters in this parameterLoader. It also provides the names for the parameters in this
class as virtual protected member functions. class as virtual protected member functions.
If you have more than a single ES in a project that need different If you have more than a single ES in a project that need different
names in the configuration files, you might consider overriding this class names in the configuration files, you might consider overriding this class
to change the names. to change the names.
@see eoEsMutate @see eoEsMutate
@ -47,9 +47,9 @@ class eoEsMutationInit
{ {
public : public :
eoEsMutationInit(eoParser& _parser, eoEsMutationInit(eoParser& _parser,
std::string _section="ES mutation parameters" ) : std::string _section="ES mutation parameters" ) :
parser(_parser), repSection(_section), parser(_parser), repSection(_section),
TauLclParam(0), TauGlbParam(0), TauBetaParam(0) {} TauLclParam(0), TauGlbParam(0), TauBetaParam(0) {}
// because we have virtual function - size // because we have virtual function - size
@ -59,7 +59,9 @@ class eoEsMutationInit
{ {
if (TauLclParam == 0) if (TauLclParam == 0)
{ {
TauLclParam = &parser.createParam(1.0, TauLclName(), "Local Tau (before normalization)", TauLclShort(), section()); TauLclParam = &parser.getORcreateParam(1.0, TauLclName(),
"Local Tau (before normalization)",
TauLclShort(), section());
} }
return TauLclParam->value(); return TauLclParam->value();
@ -69,7 +71,9 @@ class eoEsMutationInit
{ {
if (TauGlbParam == 0) if (TauGlbParam == 0)
{ {
TauGlbParam = &parser.createParam(1.0, TauGlbName(), "Global Tau (before normalization)", TauGlbShort(), section()); TauGlbParam = &parser.getORcreateParam(1.0, TauGlbName(),
"Global Tau (before normalization)",
TauGlbShort(), section());
} }
return TauGlbParam->value(); return TauGlbParam->value();
@ -79,25 +83,26 @@ class eoEsMutationInit
{ {
if (TauBetaParam == 0) if (TauBetaParam == 0)
{ {
TauBetaParam = &parser.createParam(0.0873, TauBetaName(), "Beta", TauBetaShort(), section()); TauBetaParam = &parser.getORcreateParam(0.0873, TauBetaName(),
"Beta", TauBetaShort(), section());
} }
return TauBetaParam->value(); return TauBetaParam->value();
} }
protected : protected :
virtual std::string section(void) virtual std::string section(void)
{ return repSection; } { return repSection; }
virtual std::string TauLclName(void) const { return "TauLoc"; } virtual std::string TauLclName(void) const { return "TauLoc"; }
virtual char TauLclShort(void) const { return 'l'; } virtual char TauLclShort(void) const { return 'l'; }
virtual std::string TauGlbName(void) const { return "TauGlob"; }
virtual char TauGlbShort(void) const { return 'g'; }
virtual std::string TauBetaName(void) const { return "Beta"; } virtual std::string TauGlbName(void) const { return "TauGlob"; }
virtual char TauBetaShort(void) const { return 'b'; } virtual char TauGlbShort(void) const { return 'g'; }
virtual std::string TauBetaName(void) const { return "Beta"; }
virtual char TauBetaShort(void) const { return 'b'; }
private : private :

34
eo/src/es/make_genotype_real.cpp
View file

@ -3,7 +3,7 @@
//----------------------------------------------------------------------------- //-----------------------------------------------------------------------------
// make_genotype_real.cpp // make_genotype_real.cpp
// (c) Maarten Keijzer, Marc Schoenauer and GeNeura Team, 2001 // (c) Maarten Keijzer, Marc Schoenauer and GeNeura Team, 2001
/* /*
This library is free software; you can redistribute it and/or This library is free software; you can redistribute it and/or
modify it under the terms of the GNU Lesser General Public modify it under the terms of the GNU Lesser General Public
License as published by the Free Software Foundation; either License as published by the Free Software Foundation; either
@ -27,41 +27,47 @@
#ifdef _MSC_VER #ifdef _MSC_VER
// to avoid long name warnings // to avoid long name warnings
#pragma warning(disable:4786) #pragma warning(disable:4786)
#endif #endif
/** This file contains ***INSTANCIATED DEFINITIONS*** of eoReal Init fns /** This file contains ***INSTANCIATED DEFINITIONS*** of eoReal Init fns
* 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
* Compiling this file allows one to generate part of the library (i.e. object * Compiling this file allows one to generate part of the library (i.e. object
* files that you just need to link with your own main and fitness code). * files that you just need to link with your own main and fitness code).
* *
* The corresponding ***INSTANCIATED DECLARATIONS*** are contained * The corresponding ***INSTANCIATED DECLARATIONS*** are contained
* in src/es/make_real.h * in src/es/make_real.h
* while the TEMPLATIZED code is define in make_genotype_real.h * while the TEMPLATIZED code is define in make_genotype_real.h
* *
* It is instanciated in src/es/make_genotype_real.cpp - * It is instanciated in src/es/make_genotype_real.cpp -
* and incorporated in the ga/libga.a * and incorporated in the ga/libga.a
* *
* It returns an eoInit<EOT> that can later be used to initialize * It returns an eoInit<EOT> that can later be used to initialize
* the population (see make_pop.h). * the population (see make_pop.h).
* *
* It uses a parser (to get user parameters) and a state (to store the memory) * It uses a parser (to get user parameters) and a state (to store the memory)
* the last argument is to disambiguate the call upon different instanciations. * the last argument is to disambiguate the call upon different instanciations.
* *
* WARNING: that last argument will generally be the result of calling * WARNING: that last argument will generally be the result of calling
* the default ctor of EOT, resulting in most cases in an EOT * the default ctor of EOT, resulting in most cases in an EOT
* that is ***not properly initialized*** * that is ***not properly initialized***
*/ */
// the templatized code // the templatized code
#include <es/make_genotype_real.h> #include <es/make_genotype_real.h>
/// The following function merely call the templatized do_* functions /// The following functions merely call the templatized do_* functions
eoRealInitBounded<eoReal<double> > & make_genotype(eoParser& _parser,
eoState& _state,
eoReal<double> _eo)
{
return do_make_genotype(_parser, _state, _eo);
}
eoRealInitBounded<eoReal<double> > & make_genotype(eoParser& _parser, eoState& _state, eoReal<double> _eo)
eoRealInitBounded<eoReal<eoMinimizingFitness> > & make_genotype(eoParser& _parser,
eoState& _state,
eoReal<eoMinimizingFitness> _eo)
{ {
return do_make_genotype(_parser, _state, _eo); return do_make_genotype(_parser, _state, _eo);
}
eoRealInitBounded<eoReal<eoMinimizingFitness> > & make_genotype(eoParser& _parser, eoState& _state, eoReal<eoMinimizingFitness> _eo)
{
return do_make_genotype(_parser, _state, _eo);
} }

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

@ -3,7 +3,7 @@
//----------------------------------------------------------------------------- //-----------------------------------------------------------------------------
// make_op.h - the real-valued version // make_op.h - the real-valued version
// (c) Maarten Keijzer, Marc Schoenauer and GeNeura Team, 2001 // (c) Maarten Keijzer, Marc Schoenauer and GeNeura Team, 2001
/* /*
This library is free software; you can redistribute it and/or This library is free software; you can redistribute it and/or
modify it under the terms of the GNU Lesser General Public modify it under the terms of the GNU Lesser General Public
License as published by the Free Software Foundation; either License as published by the Free Software Foundation; either
@ -56,19 +56,21 @@
* This is why the template is the complete EOT even though only the fitness * This is why the template is the complete EOT even though only the fitness
* is actually templatized here: the following only applies to bitstrings * is actually templatized here: the following only applies to bitstrings
* *
* Note : the last parameter is an eoInit: if some operator needs some info * Note : the last parameter is an eoInit: if some operator needs some info
* about the gneotypes, the init has it all (e.g. bounds, ...) * about the gneotypes, the init has it all (e.g. bounds, ...)
* Simply do * Simply do
* EOT myEO; * EOT myEO;
* _init(myEO); * _init(myEO);
* and myEO is then an ACTUAL object * and myEO is then an ACTUAL object
*/ */
template <class EOT> template <class EOT>
eoGenOp<EOT> & do_make_op(eoParameterLoader& _parser, eoState& _state, eoInit<EOT>& _init) eoGenOp<EOT> & do_make_op(eoParameterLoader& _parser, eoState& _state, eoInit<EOT>& _init)
{ {
// 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.getORcreateParam(eoParamParamType("(0,1)"), "objectBounds",
"Bounds for variables (unbounded if absent)",
'B', "Genetic Operators");
// get initisalizer size == std::vector size // get initisalizer size == std::vector size
// eoRealInitBounded<EOT> * realInit = (eoRealInitBounded<EOT>*)(&_init); // eoRealInitBounded<EOT> * realInit = (eoRealInitBounded<EOT>*)(&_init);
@ -83,7 +85,7 @@ eoGenOp<EOT> & do_make_op(eoParameterLoader& _parser, eoState& _state, eoInit<EO
eoRealVectorBounds * ptBounds; eoRealVectorBounds * ptBounds;
if (_parser.isItThere(boundsParam)) // otherwise, no bounds if (_parser.isItThere(boundsParam)) // otherwise, no bounds
{ {
/////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(); // std::pair<std::string,std::vector<std::string> > eoParamParamType & ppBounds = boundsParam.value(); // std::pair<std::string,std::vector<std::string> >
@ -98,7 +100,7 @@ eoGenOp<EOT> & do_make_op(eoParameterLoader& _parser, eoState& _state, eoInit<EO
v.push_back(r); v.push_back(r);
} }
// now create the eoRealVectorBounds object // now create the eoRealVectorBounds object
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 std::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");
@ -109,27 +111,34 @@ eoGenOp<EOT> & do_make_op(eoParameterLoader& _parser, eoState& _state, eoInit<EO
ptBounds = new eoRealVectorNoBounds(vecSize); // DON'T USE eoDummyVectorNoBounds ptBounds = new eoRealVectorNoBounds(vecSize); // DON'T USE eoDummyVectorNoBounds
// as it does not have any dimension // as it does not have any dimension
// this is a temporary version(!), // this is a temporary version(!),
// 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<std::string>& operatorParam = _parser.createParam(std::string("SGA"), "operator", "Description of the operator (SGA only now)", 'o', "Genetic Operators"); eoValueParam<std::string>& operatorParam
= _parser.getORcreateParam(std::string("SGA"), "operator",
"Description of the operator (SGA only now)",
'o', "Genetic Operators");
if (operatorParam.value() != std::string("SGA")) if (operatorParam.value() != std::string("SGA"))
throw std::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
// the relative weights for all mutations -> proportional choice // the relative weights for all mutations -> proportional choice
// and create the eoGenOp that is exactly // and create the eoGenOp that is exactly
// crossover with pcross + mutation with pmut // crossover with pcross + mutation with pmut
eoValueParam<double>& pCrossParam = _parser.createParam(0.6, "pCross", "Probability of Crossover", 'C', "Genetic Operators" ); eoValueParam<double>& pCrossParam
= _parser.getORcreateParam(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 std::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.getORcreateParam(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 std::runtime_error("Invalid pMut"); throw std::runtime_error("Invalid pMut");
@ -137,12 +146,18 @@ eoGenOp<EOT> & do_make_op(eoParameterLoader& _parser, eoState& _state, eoInit<EO
// the crossovers // the crossovers
///////////////// /////////////////
// the parameters // the parameters
eoValueParam<double>& segmentRateParam = _parser.createParam(double(1.0), "segmentRate", "Relative rate for segment crossover", 's', "Genetic Operators" ); eoValueParam<double>& segmentRateParam
= _parser.getORcreateParam(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 std::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.getORcreateParam(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 std::runtime_error("Invalid arithmeticRate"); throw std::runtime_error("Invalid arithmeticRate");
@ -154,23 +169,23 @@ eoGenOp<EOT> & do_make_op(eoParameterLoader& _parser, eoState& _state, eoInit<EO
std::cerr << "Warning: no crossover" << std::endl; std::cerr << "Warning: no crossover" << std::endl;
bCross = false; bCross = false;
} }
// Create the CombinedQuadOp // Create the CombinedQuadOp
eoPropCombinedQuadOp<EOT> *ptCombinedQuadOp = NULL; eoPropCombinedQuadOp<EOT> *ptCombinedQuadOp = NULL;
eoQuadOp<EOT> *ptQuad = NULL; eoQuadOp<EOT> *ptQuad = NULL;
if (bCross) if (bCross)
{ {
// segment crossover for bitstring - pass it the bounds // segment crossover for bitstring - pass it the bounds
ptQuad = new eoSegmentCrossover<EOT>(*ptBounds); ptQuad = new eoSegmentCrossover<EOT>(*ptBounds);
_state.storeFunctor(ptQuad); _state.storeFunctor(ptQuad);
ptCombinedQuadOp = new eoPropCombinedQuadOp<EOT>(*ptQuad, segmentRateParam.value()); ptCombinedQuadOp = new eoPropCombinedQuadOp<EOT>(*ptQuad, segmentRateParam.value());
// arithmetic crossover // arithmetic crossover
ptQuad = new eoArithmeticCrossover<EOT>(*ptBounds); ptQuad = new eoArithmeticCrossover<EOT>(*ptBounds);
_state.storeFunctor(ptQuad); _state.storeFunctor(ptQuad);
ptCombinedQuadOp->add(*ptQuad, arithmeticRateParam.value()); ptCombinedQuadOp->add(*ptQuad, arithmeticRateParam.value());
// don't forget to store the CombinedQuadOp // don't forget to store the CombinedQuadOp
_state.storeFunctor(ptCombinedQuadOp); _state.storeFunctor(ptCombinedQuadOp);
} }
@ -178,27 +193,40 @@ eoGenOp<EOT> & do_make_op(eoParameterLoader& _parser, eoState& _state, eoInit<EO
// the mutations // the mutations
///////////////// /////////////////
// the parameters // the parameters
eoValueParam<double> & epsilonParam = _parser.createParam(0.01, "epsilon", "Half-size of interval for Uniform Mutation", 'e', "Genetic Operators" ); eoValueParam<double> & epsilonParam
= _parser.getORcreateParam(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 std::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.getORcreateParam(1.0, "uniformMutRate",
"Relative rate for uniform mutation", 'u', "Genetic Operators" );
// minimum check // minimum check
if ( (uniformMutRateParam.value() < 0) ) if ( (uniformMutRateParam.value() < 0) )
throw std::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.getORcreateParam(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 std::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.getORcreateParam(1.0, "normalMutRate",
"Relative rate for Gaussian mutation",
'd', "Genetic Operators" );
// minimum check // minimum check
if ( (normalMutRateParam.value() < 0) ) if ( (normalMutRateParam.value() < 0) )
throw std::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.getORcreateParam(1.0, "sigma",
"Sigma (fixed) for Gaussian mutation",
'S', "Genetic Operators" );
// minimum check // minimum check
if ( (sigmaParam.value() < 0) ) if ( (sigmaParam.value() < 0) )
throw std::runtime_error("Invalid sigma"); throw std::runtime_error("Invalid sigma");
@ -225,14 +253,14 @@ eoGenOp<EOT> & do_make_op(eoParameterLoader& _parser, eoState& _state, eoInit<EO
_state.storeFunctor(ptMon); _state.storeFunctor(ptMon);
// create the CombinedMonOp // create the CombinedMonOp
ptCombinedMonOp = new eoPropCombinedMonOp<EOT>(*ptMon, uniformMutRateParam.value()); ptCombinedMonOp = new eoPropCombinedMonOp<EOT>(*ptMon, uniformMutRateParam.value());
// mutate exactly 1 component (uniformly) per individual // mutate exactly 1 component (uniformly) per individual
ptMon = new eoDetUniformMutation<EOT>(*ptBounds, epsilonParam.value()); ptMon = new eoDetUniformMutation<EOT>(*ptBounds, epsilonParam.value());
_state.storeFunctor(ptMon); _state.storeFunctor(ptMon);
ptCombinedMonOp->add(*ptMon, detMutRateParam.value()); ptCombinedMonOp->add(*ptMon, detMutRateParam.value());
// mutate all component using Gaussian mutation // mutate all component using Gaussian mutation
ptMon = new eoNormalMutation<EOT>(*ptBounds, sigmaParam.value()); ptMon = new eoNormalMutation<EOT>(*ptBounds, sigmaParam.value());
_state.storeFunctor(ptMon); _state.storeFunctor(ptMon);
ptCombinedMonOp->add(*ptMon, normalMutRateParam.value()); ptCombinedMonOp->add(*ptMon, normalMutRateParam.value());
_state.storeFunctor(ptCombinedMonOp); _state.storeFunctor(ptCombinedMonOp);
@ -242,7 +270,7 @@ eoGenOp<EOT> & do_make_op(eoParameterLoader& _parser, eoState& _state, eoInit<EO
// to simulate SGA (crossover with proba pCross + mutation with proba pMut // to simulate SGA (crossover with proba pCross + mutation with proba pMut
// we must construct // we must construct
// a sequential combination of // a sequential combination of
// with proba 1, a proportional combination of // with proba 1, a proportional combination of
// a QuadCopy and our crossover // a QuadCopy and our crossover
// with proba pMut, our mutation // with proba pMut, our mutation

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

@ -3,7 +3,7 @@
//----------------------------------------------------------------------------- //-----------------------------------------------------------------------------
// make_op.h - the real-valued version // make_op.h - the real-valued version
// (c) Maarten Keijzer, Marc Schoenauer and GeNeura Team, 2001 // (c) Maarten Keijzer, Marc Schoenauer and GeNeura Team, 2001
/* /*
This library is free software; you can redistribute it and/or This library is free software; you can redistribute it and/or
modify it under the terms of the GNU Lesser General Public modify it under the terms of the GNU Lesser General Public
License as published by the Free Software Foundation; either License as published by the Free Software Foundation; either
@ -59,9 +59,9 @@
* This is why the template is the complete EOT even though only the fitness * This is why the template is the complete EOT even though only the fitness
* is actually templatized here: the following only applies to bitstrings * is actually templatized here: the following only applies to bitstrings
* *
* Note : the last parameter is an eoInit: if some operator needs some info * Note : the last parameter is an eoInit: if some operator needs some info
* about the gneotypes, the init has it all (e.g. bounds, ...) * about the gneotypes, the init has it all (e.g. bounds, ...)
* Simply do * Simply do
* EOT myEO; * EOT myEO;
* _init(myEO); * _init(myEO);
* and myEO is then an ACTUAL object * and myEO is then an ACTUAL object
@ -74,24 +74,33 @@ eoGenOp<EOT> & do_make_op(eoParser& _parser, eoState& _state, eoRealInitBounded<
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.getORcreateParam(eoRealVectorBounds(vecSize,eoDummyRealNoBounds),
"objectBounds", "Bounds for variables", 'B', "Variation Operators");
// now we read Pcross and Pmut, // now we read Pcross and Pmut,
eoValueParam<std::string>& operatorParam = _parser.createParam(std::string("SGA"), "operator", "Description of the operator (SGA only now)", 'o', "Variation Operators"); eoValueParam<std::string>& operatorParam
= _parser.getORcreateParam(std::string("SGA"), "operator",
"Description of the operator (SGA only now)",
'o', "Variation Operators");
if (operatorParam.value() != std::string("SGA")) if (operatorParam.value() != std::string("SGA"))
throw std::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
// crossover with pcross + mutation with pmut // crossover with pcross + mutation with pmut
eoValueParam<double>& pCrossParam = _parser.createParam(1.0, "pCross", "Probability of Crossover", 'C', "Variation Operators" ); eoValueParam<double>& pCrossParam
= _parser.getORcreateParam(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 std::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.getORcreateParam(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 std::runtime_error("Invalid pMut"); throw std::runtime_error("Invalid pMut");
@ -100,10 +109,19 @@ eoGenOp<EOT> & do_make_op(eoParser& _parser, eoState& _state, eoRealInitBounded<
// crossover // crossover
///////////// /////////////
// ES crossover // ES crossover
eoValueParam<std::string>& crossTypeParam = _parser.createParam(std::string("global"), "crossType", "Type of ES recombination (global or standard)", 'C', "Variation Operators"); eoValueParam<std::string>& crossTypeParam
= _parser.getORcreateParam(std::string("global"), "crossType",
eoValueParam<std::string>& crossObjParam = _parser.createParam(std::string("discrete"), "crossObj", "Recombination of object variables (discrete, intermediate or none)", 'O', "Variation Operators"); "Type of ES recombination (global or standard)",
eoValueParam<std::string>& crossStdevParam = _parser.createParam(std::string("intermediate"), "crossStdev", "Recombination of mutation strategy parameters (intermediate, discrete or none)", 'S', "Variation Operators"); 'C', "Variation Operators");
eoValueParam<std::string>& crossObjParam
= _parser.getORcreateParam(std::string("discrete"), "crossObj",
"Recombination of object variables (discrete, intermediate or none)",
'O', "Variation Operators");
eoValueParam<std::string>& crossStdevParam
= _parser.getORcreateParam(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;
@ -128,7 +146,7 @@ eoGenOp<EOT> & do_make_op(eoParser& _parser, eoState& _state, eoRealInitBounded<
ptStdevAtomCross = new eoBinCloneOp<double>; ptStdevAtomCross = new eoBinCloneOp<double>;
else throw std::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() == std::string("global")) if (crossTypeParam.value() == std::string("global"))
ptCross = new eoEsGlobalXover<EOT>(*ptObjAtomCross, *ptStdevAtomCross); ptCross = new eoEsGlobalXover<EOT>(*ptObjAtomCross, *ptStdevAtomCross);
else if (crossTypeParam.value() == std::string("standard")) else if (crossTypeParam.value() == std::string("standard"))
@ -145,15 +163,15 @@ eoGenOp<EOT> & do_make_op(eoParser& _parser, eoState& _state, eoRealInitBounded<
_state.storeFunctor(ptStdevAtomCross); _state.storeFunctor(ptStdevAtomCross);
_state.storeFunctor(ptCross); _state.storeFunctor(ptCross);
// mutation // mutation
///////////// /////////////
// Ok, time to set up the self-adaptive mutation // Ok, time to set up the self-adaptive mutation
// Proxy for the mutation parameters // Proxy for the mutation parameters
eoEsMutationInit mutateInit(_parser, "Variation Operators"); eoEsMutationInit mutateInit(_parser, "Variation Operators");
eoEsMutate<EOT> & mut = _state.storeFunctor( eoEsMutate<EOT> & mut = _state.storeFunctor(
new eoEsMutate<EOT>(mutateInit, boundsParam.value())); new eoEsMutate<EOT>(mutateInit, boundsParam.value()));
// now the general op - a sequential application of crossover and mutatation // now the general op - a sequential application of crossover and mutatation
// no need to first have crossover combined with a clone as it is an // no need to first have crossover combined with a clone as it is an

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

@ -3,7 +3,7 @@
//----------------------------------------------------------------------------- //-----------------------------------------------------------------------------
// make_op.h - the real-valued version // make_op.h - the real-valued version
// (c) Maarten Keijzer, Marc Schoenauer and GeNeura Team, 2001 // (c) Maarten Keijzer, Marc Schoenauer and GeNeura Team, 2001
/* /*
This library is free software; you can redistribute it and/or This library is free software; you can redistribute it and/or
modify it under the terms of the GNU Lesser General Public modify it under the terms of the GNU Lesser General Public
License as published by the Free Software Foundation; either License as published by the Free Software Foundation; either
@ -56,9 +56,9 @@
* This is why the template is the complete EOT even though only the fitness * This is why the template is the complete EOT even though only the fitness
* is actually templatized here: the following only applies to bitstrings * is actually templatized here: the following only applies to bitstrings
* *
* Note : the last parameter is an eoInit: if some operator needs some info * Note : the last parameter is an eoInit: if some operator needs some info
* about the gneotypes, the init has it all (e.g. bounds, ...) * about the gneotypes, the init has it all (e.g. bounds, ...)
* Simply do * Simply do
* EOT myEO; * EOT myEO;
* _init(myEO); * _init(myEO);
* and myEO is then an ACTUAL object * and myEO is then an ACTUAL object
@ -71,29 +71,40 @@ eoGenOp<EOT> & do_make_op(eoParser& _parser, eoState& _state, eoRealInitBounded<
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.getORcreateParam(eoRealVectorBounds(vecSize,eoDummyRealNoBounds), "objectBounds",
"Bounds for variables", 'B', "Variation Operators");
// this is a temporary version(!), // this is a temporary version(!),
// 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<std::string>& operatorParam = _parser.createParam(std::string("SGA"), "operator", "Description of the operator (SGA only now)", 'o', "Variation Operators"); eoValueParam<std::string>& operatorParam
= _parser.getORcreateParam(std::string("SGA"), "operator",
"Description of the operator (SGA only now)",
'o', "Variation Operators");
if (operatorParam.value() != std::string("SGA")) if (operatorParam.value() != std::string("SGA"))
throw std::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
// the relative weights for all mutations -> proportional choice // the relative weights for all mutations -> proportional choice
// and create the eoGenOp that is exactly // and create the eoGenOp that is exactly
// crossover with pcross + mutation with pmut // crossover with pcross + mutation with pmut
eoValueParam<double>& pCrossParam = _parser.createParam(0.6, "pCross", "Probability of Crossover", 'C', "Variation Operators" ); eoValueParam<double>& pCrossParam
= _parser.getORcreateParam(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 std::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.getORcreateParam(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 std::runtime_error("Invalid pMut"); throw std::runtime_error("Invalid pMut");
@ -101,23 +112,35 @@ eoGenOp<EOT> & do_make_op(eoParser& _parser, eoState& _state, eoRealInitBounded<
// the crossovers // the crossovers
///////////////// /////////////////
// the parameters // the parameters
eoValueParam<double>& alphaParam = _parser.createParam(double(0.0), "alpha", "Bound for factor of linear recombinations", 'a', "Variation Operators" ); eoValueParam<double>& alphaParam
= _parser.getORcreateParam(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 std::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.getORcreateParam(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 std::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.getORcreateParam(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 std::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.getORcreateParam(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 std::runtime_error("Invalid uxoverRate"); throw std::runtime_error("Invalid uxoverRate");
@ -129,28 +152,28 @@ eoGenOp<EOT> & do_make_op(eoParser& _parser, eoState& _state, eoRealInitBounded<
std::cerr << "Warning: no crossover" << std::endl; std::cerr << "Warning: no crossover" << std::endl;
bCross = false; bCross = false;
} }
// Create the CombinedQuadOp // Create the CombinedQuadOp
eoPropCombinedQuadOp<EOT> *ptCombinedQuadOp = NULL; eoPropCombinedQuadOp<EOT> *ptCombinedQuadOp = NULL;
eoQuadOp<EOT> *ptQuad = NULL; eoQuadOp<EOT> *ptQuad = NULL;
if (bCross) if (bCross)
{ {
// segment crossover for bitstring - pass it the bounds // segment crossover for bitstring - pass it the bounds
ptQuad = new eoSegmentCrossover<EOT>(boundsParam.value(), alphaParam.value()); ptQuad = new eoSegmentCrossover<EOT>(boundsParam.value(), alphaParam.value());
_state.storeFunctor(ptQuad); _state.storeFunctor(ptQuad);
ptCombinedQuadOp = new eoPropCombinedQuadOp<EOT>(*ptQuad, segmentRateParam.value()); ptCombinedQuadOp = new eoPropCombinedQuadOp<EOT>(*ptQuad, segmentRateParam.value());
// hypercube crossover // hypercube crossover
ptQuad = new eoHypercubeCrossover<EOT>(boundsParam.value(), alphaParam.value()); ptQuad = new eoHypercubeCrossover<EOT>(boundsParam.value(), alphaParam.value());
_state.storeFunctor(ptQuad); _state.storeFunctor(ptQuad);
ptCombinedQuadOp->add(*ptQuad, hypercubeRateParam.value()); ptCombinedQuadOp->add(*ptQuad, hypercubeRateParam.value());
// uniform crossover // uniform crossover
ptQuad = new eoRealUXover<EOT>(); ptQuad = new eoRealUXover<EOT>();
_state.storeFunctor(ptQuad); _state.storeFunctor(ptQuad);
ptCombinedQuadOp->add(*ptQuad, uxoverRateParam.value()); ptCombinedQuadOp->add(*ptQuad, uxoverRateParam.value());
// don't forget to store the CombinedQuadOp // don't forget to store the CombinedQuadOp
_state.storeFunctor(ptCombinedQuadOp); _state.storeFunctor(ptCombinedQuadOp);
} }
@ -158,29 +181,46 @@ eoGenOp<EOT> & do_make_op(eoParser& _parser, eoState& _state, eoRealInitBounded<
// the mutations // the mutations
///////////////// /////////////////
// the parameters // the parameters
eoValueParam<double> & epsilonParam = _parser.createParam(0.01, "epsilon", "Half-size of interval for Uniform Mutation", 'e', "Variation Operators" ); eoValueParam<double> & epsilonParam
= _parser.getORcreateParam(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 std::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.getORcreateParam(1.0, "uniformMutRate",
"Relative rate for uniform mutation",
'u', "Variation Operators" );
// minimum check // minimum check
if ( (uniformMutRateParam.value() < 0) ) if ( (uniformMutRateParam.value() < 0) )
throw std::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.getORcreateParam(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 std::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.getORcreateParam(1.0, "normalMutRate",
"Relative rate for Gaussian mutation", 'd', "Variation Operators" );
// minimum check // minimum check
if ( (normalMutRateParam.value() < 0) ) if ( (normalMutRateParam.value() < 0) )
throw std::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.getORcreateParam(0.3, "sigma",
"Sigma (fixed) for Gaussian mutation",
's', "Variation Operators" );
eoValueParam<double> & pNormalParam = _parser.createParam(1.0, "pNormal", "Proba. to change each variable for Gaussian mutation", 's', "Variation Operators" ); eoValueParam<double> & pNormalParam
= _parser.getORcreateParam(1.0, "pNormal",
"Proba. to change each variable for Gaussian mutation",
's', "Variation Operators" );
// minimum check // minimum check
bool bMut = true; bool bMut = true;
@ -204,14 +244,14 @@ eoGenOp<EOT> & do_make_op(eoParser& _parser, eoState& _state, eoRealInitBounded<
_state.storeFunctor(ptMon); _state.storeFunctor(ptMon);
// create the CombinedMonOp // create the CombinedMonOp
ptCombinedMonOp = new eoPropCombinedMonOp<EOT>(*ptMon, uniformMutRateParam.value()); ptCombinedMonOp = new eoPropCombinedMonOp<EOT>(*ptMon, uniformMutRateParam.value());
// mutate exactly 1 component (uniformly) per individual // mutate exactly 1 component (uniformly) per individual
ptMon = new eoDetUniformMutation<EOT>(boundsParam.value(), epsilonParam.value()); ptMon = new eoDetUniformMutation<EOT>(boundsParam.value(), epsilonParam.value());
_state.storeFunctor(ptMon); _state.storeFunctor(ptMon);
ptCombinedMonOp->add(*ptMon, detMutRateParam.value()); ptCombinedMonOp->add(*ptMon, detMutRateParam.value());
// mutate all component using Gaussian mutation // mutate all component using Gaussian mutation
ptMon = new eoNormalVecMutation<EOT>(boundsParam.value(), sigmaParam.value(), pNormalParam.value()); ptMon = new eoNormalVecMutation<EOT>(boundsParam.value(), sigmaParam.value(), pNormalParam.value());
_state.storeFunctor(ptMon); _state.storeFunctor(ptMon);
ptCombinedMonOp->add(*ptMon, normalMutRateParam.value()); ptCombinedMonOp->add(*ptMon, normalMutRateParam.value());
_state.storeFunctor(ptCombinedMonOp); _state.storeFunctor(ptCombinedMonOp);
@ -221,7 +261,7 @@ eoGenOp<EOT> & do_make_op(eoParser& _parser, eoState& _state, eoRealInitBounded<
// to simulate SGA (crossover with proba pCross + mutation with proba pMut // to simulate SGA (crossover with proba pCross + mutation with proba pMut
// we must construct // we must construct
// a sequential combination of // a sequential combination of
// with proba 1, a proportional combination of // with proba 1, a proportional combination of
// a QuadCopy and our crossover // a QuadCopy and our crossover
// with proba pMut, our mutation // with proba pMut, our mutation

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

@ -123,11 +123,10 @@ void eoParser::processParam(eoParam& param, std::string section)
{ {
// this param enters the parser: add the prefix to the long name // this param enters the parser: add the prefix to the long name
if (prefix != "") if (prefix != "")
{ {
param.setLongName(prefix+param.longName()); param.setLongName(prefix+param.longName());
section = prefix + section; // and to section section = prefix + section; // and to section
} }
doRegisterParam(param); // plainly register it doRegisterParam(param); // plainly register it
params.insert(make_pair(section, &param)); params.insert(make_pair(section, &param));
} }
@ -139,9 +138,7 @@ void eoParser::doRegisterParam(eoParam& param) const
string msg = "Required parameter: " + param.longName() + " missing"; string msg = "Required parameter: " + param.longName() + " missing";
messages.push_back(msg); messages.push_back(msg);
} }
pair<bool, string> value = getValue(param); pair<bool, string> value = getValue(param);
if (value.first) if (value.first)
{ {
param.setValue(value.second); param.setValue(value.second);
@ -162,9 +159,7 @@ pair<bool, string> eoParser::getValue(eoParam& _param) const
return result; return result;
} }
} }
map<string, string>::const_iterator it = longNameMap.find(_param.longName()); map<string, string>::const_iterator it = longNameMap.find(_param.longName());
if (it != longNameMap.end()) if (it != longNameMap.end())
{ {
result.second = it->second; result.second = it->second;
@ -172,7 +167,6 @@ pair<bool, string> eoParser::getValue(eoParam& _param) const
return result; return result;
} }
// else (TODO: check environment, just long names) // else (TODO: check environment, just long names)
return result; return result;
} }
@ -188,72 +182,72 @@ void eoParser::updateParameters() const
void eoParser::readFrom(istream& is) void eoParser::readFrom(istream& is)
{ {
string str; string str;
// we must avoid processing \section{xxx} if xxx is NOT "Parser" // we must avoid processing \section{xxx} if xxx is NOT "Parser"
bool processing = true; bool processing = true;
while (is >> str) while (is >> str)
{ {
if (str.find(string("\\section{"))==0) // found section begin if (str.find(string("\\section{"))==0) // found section begin
processing = (str.find(string("Parser"))<str.size()); processing = (str.find(string("Parser"))<str.size());
if (processing) // right \section (or no \section at all) if (processing) // right \section (or no \section at all)
{ {
if (str[0] == '#') if (str[0] == '#')
{ // skip the rest of the line { // skip the rest of the line
string tempStr; string tempStr;
getline(is, tempStr); getline(is, tempStr);
} }
if (str[0] == '-') if (str[0] == '-')
{ {
if (str.size() < 2) if (str.size() < 2)
{ {
eoWarning("Missing parameter"); eoWarning("Missing parameter");
needHelp.value() = true; needHelp.value() = true;
return; return;
} }
if (str[1] == '-') // two consecutive dashes if (str[1] == '-') // two consecutive dashes
{ {
string::iterator equalLocation = find(str.begin() + 2, str.end(), '='); string::iterator equalLocation = find(str.begin() + 2, str.end(), '=');
string value; string value;
if (equalLocation == str.end()) if (equalLocation == str.end())
{ // TODO: it should be the next string { // TODO: it should be the next string
value = ""; value = "";
} }
else else
{ {
value = string(equalLocation + 1, str.end()); value = string(equalLocation + 1, str.end());
} }
string name(str.begin() + 2, equalLocation); string name(str.begin() + 2, equalLocation);
longNameMap[name] = value; longNameMap[name] = value;
} }
else // it should be a char else // it should be a char
{ {
string value = "1"; // flags do not need a special string value = "1"; // flags do not need a special
if (str.size() >= 2) if (str.size() >= 2)
{ {
if (str[2] == '=') if (str[2] == '=')
{ {
if (str.size() >= 3) if (str.size() >= 3)
value = string(str.begin() + 3, str.end()); value = string(str.begin() + 3, str.end());
} }
else else
{ {
value = string(str.begin() + 2, str.end()); value = string(str.begin() + 2, str.end());
} }
} }
shortNameMap[str[1]] = value; shortNameMap[str[1]] = value;
} }
} }
} }
} }
updateParameters(); updateParameters();
} }
void eoParser::printOn(ostream& os) const void eoParser::printOn(ostream& os) const

60
eo/src/utils/eoParser.h
View file

@ -24,7 +24,7 @@
*/ */
//----------------------------------------------------------------------------- //-----------------------------------------------------------------------------
/** /**
CVS Info: $Date: 2005-08-29 07:50:50 $ $Version$ $Author: kuepper $ CVS Info: $Date: 2005-09-12 17:53:24 $ $Version$ $Author: kuepper $
*/ */
#ifndef eoParser_h #ifndef eoParser_h
#define eoParser_h #define eoParser_h
@ -73,29 +73,27 @@ public :
* @param _required If it is a necessary parameter or not * @param _required If it is a necessary parameter or not
*/ */
template <class ValueType> template <class ValueType>
eoValueParam<ValueType>& createParam eoValueParam<ValueType>& createParam(ValueType _defaultValue,
(ValueType _defaultValue, std::string _longName,
std::string _longName, std::string _description,
std::string _description, char _shortHand = 0,
char _shortHand = 0, std::string _section = "",
std::string _section = "", bool _required = false)
bool _required = false) {
{ eoValueParam<ValueType>* p = new eoValueParam<ValueType>(_defaultValue,
eoValueParam<ValueType>* p = new eoValueParam<ValueType>(_defaultValue, _longName,
_longName, _description,
_description, _shortHand,
_shortHand, _required);
_required); ownedParams.push_back(p);
ownedParams.push_back(p); processParam(*p, _section);
processParam(*p, _section); return *p;
return *p; }
}
private : private :
std::vector<eoParam*> ownedParams; std::vector<eoParam*> ownedParams;
}; };
@ -198,7 +196,10 @@ public:
/** Make sure parameter has specific value /** Set parameter value or create parameter
This makes sure that the specified parameter has the given value.
If the parameter does not exist yet, it is created.
This requires that operator<< is defined for ValueType. This requires that operator<< is defined for ValueType.
*/ */
@ -207,18 +208,19 @@ public:
std::string _description, char _shortHand = 0, std::string _description, char _shortHand = 0,
std::string _section = "", bool _required = false) std::string _section = "", bool _required = false)
{ {
eoParam *param = getParamWithLongName(_longName); eoValueParam<ValueType>& param = createParam(_defaultValue, _longName, _description,
if(0 == param) { _shortHand, _section, _required);
createParam(_defaultValue, _longName, _description,
_shortHand, _section, _required);
} else {
#ifdef HAVE_SSTREAM #ifdef HAVE_SSTREAM
std::ostringstream os; std::ostringstream os;
#else #else
std::ostrstream os; std::ostrstream os;
#endif #endif
os << _defaultValue; os << _defaultValue;
dynamic_cast<eoValueParam<int> *>(param)->setValue(os.str()); if(isItThere(param)) {
param.setValue(os.str());
} else {
longNameMap[_longName] = os.str();
shortNameMap[_shortHand] = os.str();
} }
} }

22
eo/src/utils/eoRealBounds.cpp
View file

@ -1,7 +1,7 @@
#ifdef _MSC_VER #ifdef _MSC_VER
// to avoid long name warnings // to avoid long name warnings
#pragma warning(disable:4786) #pragma warning(disable:4786)
#endif #endif
#ifdef HAVE_CONFIG_H #ifdef HAVE_CONFIG_H
#include <config.h> #include <config.h>
@ -18,7 +18,7 @@
#include "eoRealVectorBounds.h" #include "eoRealVectorBounds.h"
// the global dummy bounds // the global dummy bounds
// (used for unbounded variables when bounds are required) // (used for unbounded variables when bounds are required)
eoRealNoBounds eoDummyRealNoBounds; eoRealNoBounds eoDummyRealNoBounds;
eoRealVectorNoBounds eoDummyVectorNoBounds(0); eoRealVectorNoBounds eoDummyVectorNoBounds(0);
@ -74,7 +74,7 @@ eoRealVectorBounds::eoRealVectorBounds(const eoRealVectorBounds & _b):
// the readFrom method of eoRealVectorNoBounds: // the readFrom method of eoRealVectorNoBounds:
// only calls the readFrom(string) - for param reading // only calls the readFrom(string) - for param reading
void eoRealVectorBounds::readFrom(std::istream& _is) void eoRealVectorBounds::readFrom(std::istream& _is)
{ {
std::string value; std::string value;
_is >> value; _is >> value;
@ -95,7 +95,7 @@ void eoRealVectorBounds::readFrom(std::string _value)
ownedBounds.resize(0); ownedBounds.resize(0);
factor.resize(0); factor.resize(0);
resize(0); resize(0);
// now read // now read
std::string delim(",; "); std::string delim(",; ");
while (_value.size()>0) while (_value.size()>0)
@ -129,7 +129,7 @@ void eoRealVectorBounds::readFrom(std::string _value)
std::string sBounds = _value.substr(posDeb+1, posFin-posDeb-1); std::string sBounds = _value.substr(posDeb+1, posFin-posDeb-1);
// and remove from original string // and remove from original string
_value = _value.substr(posFin+1); _value = _value.substr(posFin+1);
remove_leading(sBounds, delim); remove_leading(sBounds, delim);
size_t posDelim = sBounds.find_first_of(delim); size_t posDelim = sBounds.find_first_of(delim);
if (posDelim >= sBounds.size()) if (posDelim >= sBounds.size())
@ -193,10 +193,10 @@ void eoRealVectorBounds::adjust_size(unsigned _dim)
} }
} }
/** the constructor for eoGeneralRealBound - from a string /** the constructor for eoGeneralRealBound - from a string
* very similar to the eoRealVectorBounds::readFrom above * very similar to the eoRealVectorBounds::readFrom above
* but was written much later so the readFrom does not call this one * but was written much later so the readFrom does not call this one
* as it should do * as it should do
*/ */
eoRealBounds* eoGeneralRealBounds::getBoundsFromString(std::string _value) eoRealBounds* eoGeneralRealBounds::getBoundsFromString(std::string _value)
{ {
@ -208,7 +208,7 @@ eoRealBounds* eoGeneralRealBounds::getBoundsFromString(std::string _value)
// look for opening char // look for opening char
size_t posDeb = _value.find_first_of(beginOrClose); // allow ]a,b] size_t posDeb = _value.find_first_of(beginOrClose); // allow ]a,b]
if (posDeb >= _value.size()) // nothing left to read if (posDeb >= _value.size()) // nothing left to read
throw std::runtime_error("Syntax error in eoGeneralRealBounds Ctor"); throw std::runtime_error("Syntax error in eoGeneralRealBounds Ctor");
// ending char: next {}() after posDeb // ending char: next {}() after posDeb
@ -220,7 +220,7 @@ eoRealBounds* eoGeneralRealBounds::getBoundsFromString(std::string _value)
std::string sBounds = _value.substr(posDeb+1, posFin-posDeb-1); std::string sBounds = _value.substr(posDeb+1, posFin-posDeb-1);
// and remove from original string // and remove from original string
_value = _value.substr(posFin+1); _value = _value.substr(posFin+1);
remove_leading(sBounds, delim); remove_leading(sBounds, delim);
size_t posDelim = sBounds.find_first_of(delim); size_t posDelim = sBounds.find_first_of(delim);
if (posDelim >= sBounds.size()) if (posDelim >= sBounds.size())
@ -260,7 +260,7 @@ eoRealBounds* eoGeneralRealBounds::getBoundsFromString(std::string _value)
if (maxBound <= minBound) if (maxBound <= minBound)
throw std::runtime_error("Syntax error in eoGeneralRealBounds Ctor"); throw std::runtime_error("Syntax error in eoGeneralRealBounds Ctor");
locBound = new eoRealInterval(minBound, maxBound); locBound = new eoRealInterval(minBound, maxBound);
} }
else if (!minBounded && !maxBounded) // no bound at all else if (!minBounded && !maxBounded) // no bound at all
locBound = new eoRealNoBounds; locBound = new eoRealNoBounds;
else if (!minBounded && maxBounded) else if (!minBounded && maxBounded)