diff --git a/eo/src/eoInt.h b/eo/src/eoInt.h index 2742edaa1..e4f350795 100644 --- a/eo/src/eoInt.h +++ b/eo/src/eoInt.h @@ -33,6 +33,8 @@ /** eoInt: implementation of simple integer-valued chromosome. * based on eoVector class + * + * @ingroup Representations */ template class eoInt: public eoVector { diff --git a/eo/src/eoIntegerVelocity.h b/eo/src/eoIntegerVelocity.h index 76f7161a3..1802dab5b 100644 --- a/eo/src/eoIntegerVelocity.h +++ b/eo/src/eoIntegerVelocity.h @@ -40,6 +40,8 @@ * At step t: v(t+1)= c1 * v(t) + c2 * r2 * ( xbest(t)-x(t) ) + c3 * r3 * ( gbest(t) - x(t) ) * v(t) is an INT for any time step * (ci given and Ri chosen at random in [0;1]). +* +* @ingroup Variators */ template < class POT > class eoIntegerVelocity:public eoVelocity < POT > { diff --git a/eo/src/eoInvalidateOps.h b/eo/src/eoInvalidateOps.h index 4643c7270..aa5a18532 100644 --- a/eo/src/eoInvalidateOps.h +++ b/eo/src/eoInvalidateOps.h @@ -29,6 +29,8 @@ #include +/** @addtogroup Utilities + /** One of the invalidator operators. Use this one as a 'hat' on an operator that is defined to work on a generic datatype. This functor will then check diff --git a/eo/src/eoLinearDecreasingWeightUp.h b/eo/src/eoLinearDecreasingWeightUp.h index eb1af0bec..87f489423 100644 --- a/eo/src/eoLinearDecreasingWeightUp.h +++ b/eo/src/eoLinearDecreasingWeightUp.h @@ -37,6 +37,8 @@ * Nt is the total number of generations/event * w(0) is the initial weight * w(Nt) is the last inertia weight + * + * @ingroup Variators */ template class eoLinearDecreasingWeightUp:public eoWeightUpdater { diff --git a/eo/src/eoLinearFitScaling.h b/eo/src/eoLinearFitScaling.h index e5f4c8192..75598c934 100644 --- a/eo/src/eoLinearFitScaling.h +++ b/eo/src/eoLinearFitScaling.h @@ -38,6 +38,8 @@ * truncate negative values to 0 - * * to be used within an eoSelectFromWorth object + * + * @ingroup Selectors */ template class eoLinearFitScaling : public eoPerf2Worth // false: do not cache fitness diff --git a/eo/src/eoLinearTopology.h b/eo/src/eoLinearTopology.h index 4c61bf00d..99457b674 100644 --- a/eo/src/eoLinearTopology.h +++ b/eo/src/eoLinearTopology.h @@ -37,6 +37,8 @@ * One of the local best strategies for particle swarm optimization. Each particle has a fixed number of neighbours, ans * the neighborhood is social. * The topology is never modified during the flight. + * + * @ingroup Selectors */ template < class POT > class eoLinearTopology:public eoTopology < POT > diff --git a/eo/src/eoMGGReplacement.h b/eo/src/eoMGGReplacement.h index 55eaaa54b..a625e1e85 100644 --- a/eo/src/eoMGGReplacement.h +++ b/eo/src/eoMGGReplacement.h @@ -44,6 +44,7 @@ eoMGGReplacement is an eoReplacement: - select best N-1 of this merged population (detTournament only at the moment) - put them back into parent population +@ingroup Replacors */ template diff --git a/eo/src/eoMerge.h b/eo/src/eoMerge.h index 0e359ae53..1e2b2bf45 100644 --- a/eo/src/eoMerge.h +++ b/eo/src/eoMerge.h @@ -43,6 +43,9 @@ * two populations into one (the second argument). * Note that the algorithms assume that the second argument denotes the * next generation. + * + * @ingroup Core + * @ingroup Replacors */ template class eoMerge: public eoBF&, eoPop&, void> @@ -51,6 +54,8 @@ template class eoMerge: public eoBF&, eoPop class eoElitism : public eoMerge { @@ -103,6 +108,7 @@ private : /** No elite +@ingroup Replacors */ template class eoNoElitism : public eoElitism { @@ -112,6 +118,7 @@ template class eoNoElitism : public eoElitism /** Very elitist class, copies entire population into next gen +@ingroup Replacors */ template class eoPlus : public eoMerge { diff --git a/eo/src/eoMergeReduce.h b/eo/src/eoMergeReduce.h index f0c6a1b5a..b4c717528 100644 --- a/eo/src/eoMergeReduce.h +++ b/eo/src/eoMergeReduce.h @@ -45,6 +45,7 @@ Replacement strategies that combine en eoMerge and an eoReduce. /** eoMergeReduce: abstract replacement strategy that is just an application of an embedded merge, followed by an embedded reduce +@ingroup Replacors */ template class eoMergeReduce : public eoReplacement @@ -68,6 +69,7 @@ class eoMergeReduce : public eoReplacement /** ES type of replacement strategy: first add parents to population, then truncate +@ingroup Replacors */ template class eoPlusReplacement : public eoMergeReduce @@ -82,6 +84,7 @@ class eoPlusReplacement : public eoMergeReduce /** ES type of replacement strategy: ignore parents, truncate offspring +@ingroup Replacors */ template class eoCommaReplacement : public eoMergeReduce @@ -97,6 +100,7 @@ class eoCommaReplacement : public eoMergeReduce /** EP type of replacement strategy: first add parents to population, then truncate using EP tournament +@ingroup Replacors */ template class eoEPReplacement : public eoMergeReduce diff --git a/eo/src/eoNeighborhood.h b/eo/src/eoNeighborhood.h index 79857838c..fa0edd3f8 100644 --- a/eo/src/eoNeighborhood.h +++ b/eo/src/eoNeighborhood.h @@ -29,6 +29,8 @@ /** * Abstract class for neighborboods. Used for particle swarm optimization * topology strategies. Can be social or physical. + * + * @ingroup Selectors */ template < class POT > class eoNeighborhood { diff --git a/eo/src/eoOneToOneBreeder.h b/eo/src/eoOneToOneBreeder.h index cd18edd19..4036377ce 100644 --- a/eo/src/eoOneToOneBreeder.h +++ b/eo/src/eoOneToOneBreeder.h @@ -38,15 +38,15 @@ #include #include -/***************************************************************************** - * eoOneToOneBreeder: transforms a population using +/** eoOneToOneBreeder: transforms a population using * - an operator that MODIFIES only one parent from the populator * (though it can use any number aside) and thus generates ONE offspring) * - a local replacement between the parent and its offspring * * Typically, Differential Evolution (Storn and Price 94) and Deb et al's * G3 can be built on this - **************************************************************************** + * + * @ingroup Combination */ template class eoOneToOneBreeder: public eoBreed diff --git a/eo/src/eoOp.h b/eo/src/eoOp.h index f263ef69f..849a6da04 100644 --- a/eo/src/eoOp.h +++ b/eo/src/eoOp.h @@ -29,6 +29,7 @@ #include #include #include + /** @defgroup Operators Evolutionary Operators diff --git a/eo/src/eoOpContainer.h b/eo/src/eoOpContainer.h index 6a31ced9e..70252a49d 100644 --- a/eo/src/eoOpContainer.h +++ b/eo/src/eoOpContainer.h @@ -37,6 +37,8 @@ * the differnet instances of eoOpContainer: * an ***absolute*** probability in the sequential version, and * a ***relative*** weight in the proportional version + * + * @ingroup Combination */ template class eoOpContainer : public eoGenOp @@ -83,6 +85,8 @@ class eoOpContainer : public eoGenOp * note the mark, rewind, unmark cycle * here operators are repeatedly applied on the same individual(s) * not all too elegant, but it sort of works... + * + * @ingroup Combination */ template class eoSequentialOp : public eoOpContainer diff --git a/eo/src/eoOpSelMason.h b/eo/src/eoOpSelMason.h index 6c1d80924..02f927771 100644 --- a/eo/src/eoOpSelMason.h +++ b/eo/src/eoOpSelMason.h @@ -20,21 +20,20 @@ Contact: todos@geneura.ugr.es, http://geneura.ugr.es */ -//----------------------------------------------------------------------------- #ifndef _EOOPSELMASON_H #define _EOOPSELMASON_H -//----------------------------------------------------------------------------- -#include #include // for eoFactory and eoOpFactory #include -//----------------------------------------------------------------------------- /** EO Mason, or builder, for operator selectors. A builder must allocate memory -to the objects it builds, and then deallocate it when it gets out of scope*/ +to the objects it builds, and then deallocate it when it gets out of scope + +@ingroup Utilities +*/ template class eoOpSelMason: public eoFactory > { diff --git a/eo/src/eoOrderXover.h b/eo/src/eoOrderXover.h index 3d0e89393..211af69b5 100644 --- a/eo/src/eoOrderXover.h +++ b/eo/src/eoOrderXover.h @@ -20,6 +20,8 @@ * p1 : [1|2,4,3|6,5] and p2 : [4|5,3,1|6,2] generate two children: * c1 = [2,4,3,6,5,1] 2,4,3 taken from p1 and 6,5,1 from p2 * c2 = [5,3,1,6,2,4] 5,3,1 taken from p2 and 6,2,4 from p1 + * + * @ingroup Variators */ template class eoOrderXover: public eoQuadOp { diff --git a/eo/src/eoPerf2Worth.h b/eo/src/eoPerf2Worth.h index 35d2f28e3..9f1746ecf 100644 --- a/eo/src/eoPerf2Worth.h +++ b/eo/src/eoPerf2Worth.h @@ -38,6 +38,9 @@ /** @brief Base class to transform raw fitnesses into fitness for selection @see eoSelectFromWorth + +@ingroup Selectors +@ingroup Utilities */ template class eoPerf2Worth : public eoUF&, void>, public eoValueParam > @@ -106,6 +109,8 @@ public: /** Perf2Worth with fitness cache +@ingroup Selectors +@ingroup Utilities */ template class eoPerf2WorthCached : public eoPerf2Worth @@ -225,7 +230,10 @@ public: -/** A dummy perf2worth, just in case you need it */ +/** A dummy perf2worth, just in case you need it +@ingroup Selectors +@ingroup Utilities +*/ template class eoNoPerf2Worth : public eoPerf2Worth { diff --git a/eo/src/eoPeriodicContinue.h b/eo/src/eoPeriodicContinue.h index 7b47af6ea..c96391c85 100644 --- a/eo/src/eoPeriodicContinue.h +++ b/eo/src/eoPeriodicContinue.h @@ -1,7 +1,5 @@ // -*- mode: c++; c-indent-level: 4; c++-member-init-indent: 8; comment-column: 35; -*- -// "eoFreqContinue.h" - // (c) OPAC Team, LIFL, Feb. 2006 /* This library is free software; you can redistribute it and/or @@ -27,16 +25,25 @@ #include #include +/** A continue that becomes true periodically. + */ template class eoPeriodicContinue: public eoContinue { public: /** Constructor. The period is given in parameter. */ - eoPeriodicContinue (unsigned __period, unsigned __init_counter = 0); + eoPeriodicContinue (unsigned __period, unsigned __init_counter = 0) : + period (__period), counter (__init_counter) + {} + /** It returns 'true' only if the current number of generations modulo the period doen't equal to zero. */ - bool operator () (const eoPop & pop); + bool operator () (const eoPop & pop) + { + return ((++ counter) % period) != 0 ; + } + private: @@ -45,19 +52,5 @@ private: unsigned counter; }; - -template -eoPeriodicContinue :: eoPeriodicContinue (unsigned __period, unsigned __init_counter - ) : period (__period), - counter (__init_counter) { - -} - -template -bool eoPeriodicContinue :: operator () (const eoPop & __pop) { - - return ((++ counter) % period) != 0 ; -} - #endif diff --git a/eo/src/eoPersistent.cpp b/eo/src/eoPersistent.cpp index 253c5803b..63e906ca7 100644 --- a/eo/src/eoPersistent.cpp +++ b/eo/src/eoPersistent.cpp @@ -7,7 +7,6 @@ //Implementation of these objects -//----------------------------------------------------------------------------- std::istream & operator >> ( std::istream& _is, eoPersistent& _o ) { _o.readFrom(_is); diff --git a/eo/src/eoPop.h b/eo/src/eoPop.h index b2d58fac6..7eb726c56 100644 --- a/eo/src/eoPop.h +++ b/eo/src/eoPop.h @@ -48,8 +48,9 @@ * and eoInit derived object. in the ctor. * EOT must also have a copy ctor, since temporaries are created and then * passed to the eoInit object + * + * @ingroup Core */ - template class eoPop: public std::vector, public eoObject, public eoPersistent { @@ -333,9 +334,6 @@ public: for (unsigned i=0; ioperator[](i).invalidate(); } - - protected: - }; #endif diff --git a/eo/src/eoPopEvalFunc.h b/eo/src/eoPopEvalFunc.h index e03279225..9f5fca594 100644 --- a/eo/src/eoPopEvalFunc.h +++ b/eo/src/eoPopEvalFunc.h @@ -44,6 +44,8 @@ * * Basic parallelization (synchronous standard evolution engine): * call the slaves and wait for the results + * + * @ingroup Evaluation */ template class eoPopEvalFunc : public eoBF & , eoPop &, void> @@ -55,6 +57,8 @@ class eoPopEvalFunc : public eoBF & , eoPop &, void> /** eoPopLoopEval: an instance of eoPopEvalFunc that simply applies * a private eoEvalFunc to all offspring + * + * @ingroup Evaluation */ template class eoPopLoopEval : public eoPopEvalFunc { @@ -79,6 +83,8 @@ private: /** eoPopLoopEval: an instance of eoPopEvalFunc that simply applies * a private eoEvalFunc to all offspring AND ALL PARENTS * as the fitness is supposed here to vary + * + * @ingroup Evaluation */ template class eoTimeVaryingLoopEval : public eoPopEvalFunc { diff --git a/eo/src/eoPopulator.h b/eo/src/eoPopulator.h index 34b4f2360..eaf8f8410 100644 --- a/eo/src/eoPopulator.h +++ b/eo/src/eoPopulator.h @@ -33,7 +33,11 @@ It is an eoPop but also behaves like an eoPop::iterator as far as operator* and operator++ are concerned - See eoGenOp and eoOpContainer + @see eoGenOp + @see eoOpContainer + + @ingroup Core + @ingroup Utilities */ template class eoPopulator diff --git a/eo/src/eoPropGAGenOp.h b/eo/src/eoPropGAGenOp.h index e4305e29c..44ccc7a53 100644 --- a/eo/src/eoPropGAGenOp.h +++ b/eo/src/eoPropGAGenOp.h @@ -33,11 +33,13 @@ // class eoSGAGenOp /////////////////////////////////////////////////////////////////////////////// -/** *************************************************************************** +/** * eoPropGAGenOp (for Simple GA, but Proportional) * choice between Crossover, mutation or cloining * with respect to given relatve weights - *****************************************************************************/ + * + * @ingroup Combination + */ template class eoPropGAGenOp : public eoGenOp { diff --git a/eo/src/eoProportionalSelect.h b/eo/src/eoProportionalSelect.h index 8c01b7503..c5a895ff4 100644 --- a/eo/src/eoProportionalSelect.h +++ b/eo/src/eoProportionalSelect.h @@ -33,15 +33,15 @@ #include #include #include -//----------------------------------------------------------------------------- + /** eoProportionalSelect: select an individual proportional to her stored fitness value Changed the algorithm to make use of a cumulative array of fitness scores, This changes the algorithm from O(n) per call to O(log n) per call. (MK) -*/ -//----------------------------------------------------------------------------- + @ingroup Selectors +*/ template class eoProportionalSelect: public eoSelectOne { public: diff --git a/eo/src/eoRandomRealWeightUp.h b/eo/src/eoRandomRealWeightUp.h index ff7db7553..b929504c1 100644 --- a/eo/src/eoRandomRealWeightUp.h +++ b/eo/src/eoRandomRealWeightUp.h @@ -34,6 +34,8 @@ * Update an inertia weight by assigning it an (uniform) random value. * The weight is a basic feature to evaluate the velocity of a particle in * swarm optimization. + * + * @ingroup Variators */ class eoRandomRealWeightUp:public eoWeightUpdater { diff --git a/eo/src/eoRandomSelect.h b/eo/src/eoRandomSelect.h index 6569207b7..6d99f17ed 100644 --- a/eo/src/eoRandomSelect.h +++ b/eo/src/eoRandomSelect.h @@ -22,12 +22,10 @@ Marc.Schoenauer@polytechnique.fr mak@dhi.dk */ -//----------------------------------------------------------------------------- #ifndef eoRandomSelect_h #define eoRandomSelect_h -//----------------------------------------------------------------------------- /** This file contains straightforward selectors: * eoRandomSelect returns an individual uniformly selected * eoBestSelect always return the best individual @@ -37,10 +35,10 @@ #include #include -//----------------------------------------------------------------------------- -/** eoRandomSelect: a selection method that selects ONE individual randomly */ -//----------------------------------------------------------------------------- - +/** eoRandomSelect: a selection method that selects ONE individual randomly + * + * @ingroup Selectors + */ template class eoRandomSelect: public eoSelectOne { public: @@ -52,11 +50,11 @@ template class eoRandomSelect: public eoSelectOne } }; -//----------------------------------------------------------------------------- /** eoBestSelect: a selection method that always return the best - * (mainly for testing purposes) */ -//----------------------------------------------------------------------------- - + * (mainly for testing purposes) + * + * @ingroup Selectors + */ template class eoBestSelect: public eoSelectOne { public: @@ -68,13 +66,11 @@ template class eoBestSelect: public eoSelectOne } }; -//----------------------------------------------------------------------------- /** eoNoSelect: returns all individual in order WITHOUT USING FITNESS!!! * looping back to the beginning when exhasuted * + * @ingroup Selectors */ -//----------------------------------------------------------------------------- - template class eoNoSelect: public eoSelectOne { public: diff --git a/eo/src/eoRanking.h b/eo/src/eoRanking.h index def90dd81..ec8120064 100644 --- a/eo/src/eoRanking.h +++ b/eo/src/eoRanking.h @@ -33,6 +33,8 @@ * COmputes the ranked fitness: fitnesses range in [m,M] * with m=2-pressure/popSize and M=pressure/popSize. * in between, the progression depstd::ends on exponent (linear if 1). + * + * @ingroup Selectors */ template class eoRanking : public eoPerf2Worth // false: do not cache fitness diff --git a/eo/src/eoRankingSelect.h b/eo/src/eoRankingSelect.h index fd5619a94..465dca564 100644 --- a/eo/src/eoRankingSelect.h +++ b/eo/src/eoRankingSelect.h @@ -35,8 +35,9 @@ * is an eoRouletteWorthSelect, i.e. a selector using a std::vector of worthes * rather than the raw fitness (see eoSelectFromWorth.h) * uses an internal eoRanking object which is an eoPerf2Worth + * + * @ingroup Selectors */ - template class eoRankingSelect: public eoRouletteWorthSelect { diff --git a/eo/src/eoRealBoundModifier.h b/eo/src/eoRealBoundModifier.h index d9fa099e6..e9d21c4c3 100644 --- a/eo/src/eoRealBoundModifier.h +++ b/eo/src/eoRealBoundModifier.h @@ -20,25 +20,33 @@ Contact: thomas.legrand@lifl.fr */ -//----------------------------------------------------------------------------- #ifndef EOREALBOUNDMODIFIER_H #define EOREALBOUNDMODIFIER_H -//----------------------------------------------------------------------------- #include #include -//----------------------------------------------------------------------------- + +/** @defgroup Bounds Bounds management + * + * Bounds are a set of utilities that permits to manage ranges of existence + * for variables. For example to restrain vectors or parameters to a given domain. + * + * @ingroup Utilities + */ /** * Abstract class for eoRealVectorBounds modifier. * Used to modify the bounds included into the eoRealVectorBounds object. + * + * @ingroup Bounds */ class eoRealBoundModifier: public eoBF < eoRealBaseVectorBounds &,unsigned,void > {}; /** * An eoRealBoundModifier that modify nothing ! + * @ingroup Bounds */ class eoDummyRealBoundModifier: public eoRealBoundModifier { diff --git a/eo/src/eoRealParticle.h b/eo/src/eoRealParticle.h index 96642c23b..14326558c 100644 --- a/eo/src/eoRealParticle.h +++ b/eo/src/eoRealParticle.h @@ -31,6 +31,8 @@ /** eoRealParticle: Implementation of a real-coded particle for * particle swarm optimization. Positions, velocities and best positions are real-coded. + * + * @ingroup Real */ template < class FitT> class eoRealParticle: public eoVectorParticle diff --git a/eo/src/eoReduce.h b/eo/src/eoReduce.h index 9d5ff97b4..8783c59f5 100644 --- a/eo/src/eoReduce.h +++ b/eo/src/eoReduce.h @@ -40,12 +40,15 @@ At the moment, limited to truncation - with 2 different methods, one that sorts the whole population, and one that repeatidely kills the worst. Ideally, we should be able to choose at run-time!!! -*/ + @ingroup Replacors +*/ template class eoReduce: public eoBF&, unsigned, void> {}; -/** truncation method using sort */ +/** truncation method using sort + @ingroup Replacors + */ template class eoTruncate : public eoReduce { void operator()(eoPop& _newgen, unsigned _newsize) @@ -60,7 +63,9 @@ template class eoTruncate : public eoReduce } }; -/** random truncation */ +/** random truncation + @ingroup Replacors + * */ template class eoRandomReduce : public eoReduce { void operator()(eoPop& _newgen, unsigned _newsize) @@ -79,6 +84,7 @@ template class eoRandomReduce : public eoReduce /** EP truncation method (some global stochastic tournament + sort) Softer selective pressure than pure truncate + @ingroup Replacors */ template class eoEPReduce : public eoReduce { @@ -162,6 +168,7 @@ private: /** a truncate class that does not sort, but repeatidely kills the worse. To be used in SSGA-like replacements (e.g. see eoSSGAWorseReplacement) + @ingroup Replacors */ template class eoLinearTruncate : public eoReduce @@ -183,6 +190,7 @@ class eoLinearTruncate : public eoReduce /** a truncate class based on a repeated deterministic (reverse!) tournament To be used in SSGA-like replacements (e.g. see eoSSGADetTournamentReplacement) + @ingroup Replacors */ template class eoDetTournamentTruncate : public eoReduce @@ -231,6 +239,7 @@ private: /** a truncate class based on a repeated deterministic (reverse!) tournament To be used in SSGA-like replacements (e.g. see eoSSGAStochTournamentReplacement) + @ingroup Replacors */ template class eoStochTournamentTruncate : public eoReduce diff --git a/eo/src/eoReduceMerge.h b/eo/src/eoReduceMerge.h index 52088cd00..03e025ac6 100644 --- a/eo/src/eoReduceMerge.h +++ b/eo/src/eoReduceMerge.h @@ -37,6 +37,9 @@ #include //----------------------------------------------------------------------------- +/** @addtogroup Replacors + * @{ + */ /** eoReduceMerge: Replacement strategies that start by reducing the parents, @@ -116,4 +119,5 @@ class eoSSGAStochTournamentReplacement : public eoReduceMerge eoPlus plus; }; +/** @} */ #endif diff --git a/eo/src/eoReduceMergeReduce.h b/eo/src/eoReduceMergeReduce.h index 05854ea76..41629267a 100644 --- a/eo/src/eoReduceMergeReduce.h +++ b/eo/src/eoReduceMergeReduce.h @@ -43,8 +43,8 @@ eoReduceMergeReduce is an eoReplacement: - merges reduced populations - reduces resulting merged pop if necessary + @ingroup Replacors */ - template class eoReduceMergeReduce : public eoReplacement { diff --git a/eo/src/eoReduceSplit.h b/eo/src/eoReduceSplit.h index 915de4741..758f48bde 100644 --- a/eo/src/eoReduceSplit.h +++ b/eo/src/eoReduceSplit.h @@ -35,6 +35,10 @@ #include // eoReduce #include +/** @addtogroup Replacors + * @{ + */ + /** * eoReduceSplit: reduce the pop to the specified size * AND eventually returns the eliminated guys @@ -320,4 +324,5 @@ private: //----------------------------------------------------------------------------- +/** @} */ #endif diff --git a/eo/src/eoReplacement.h b/eo/src/eoReplacement.h index ca2caa0e5..972aa61a4 100644 --- a/eo/src/eoReplacement.h +++ b/eo/src/eoReplacement.h @@ -37,12 +37,6 @@ //----------------------------------------------------------------------------- /** -eoReplacement: the base class for all replacement functors. - -NOTE: 2 eoPop as arguments -the resulting population should be in the first argument (replace -parents by offspring)! The second argument can contain any rubbish - --- The eoMergeReduce, combination of eoMerge and eoReduce, can be found in file eoMergeReduce.h @@ -69,16 +63,22 @@ MS 12/12/2000 */ +/** The base class for all replacement functors. -//@{ +NOTE: two eoPop as arguments +the resulting population should be in the first argument (replace +parents by offspring)! The second argument can contain any rubbish -/// + @ingroup Replacors + */ template class eoReplacement : public eoBF&, eoPop&, void> {}; /** generational replacement == swap populations + + @ingroup Replacors */ template class eoGenerationalReplacement : public eoReplacement @@ -97,6 +97,8 @@ Copies in the new pop the best individual from the old pop, AFTER normal replacement, if the best of the new pop is worse than the best of the old pop. Removes the worse individual from the new pop. This could be changed by adding a selector there... + + @ingroup Replacors */ template class eoWeakElitistReplacement : public eoReplacement @@ -123,6 +125,4 @@ private: eoReplacement & replace; }; -//@} - #endif diff --git a/eo/src/eoRingTopology.h b/eo/src/eoRingTopology.h index bd5ba7b52..352a6e2aa 100644 --- a/eo/src/eoRingTopology.h +++ b/eo/src/eoRingTopology.h @@ -39,6 +39,8 @@ * The neighborhoods are built using a ring based on each particle's indice and * do not change for all the time steps. Only the best particle in each neighborhood is * potentially updated thanks to the "updateNeighborhood" method. + * + * @ingroup Selectors */ template < class POT > class eoRingTopology:public eoTopology { diff --git a/eo/src/eoSGAGenOp.h b/eo/src/eoSGAGenOp.h index a6533f072..922a46ca9 100644 --- a/eo/src/eoSGAGenOp.h +++ b/eo/src/eoSGAGenOp.h @@ -33,14 +33,16 @@ // class eoSGAGenOp /////////////////////////////////////////////////////////////////////////////// -/** *************************************************************************** +/** * eoSGAGenOp (for Simple GA) mimicks the usual crossover with proba pCross + * mutation with proba pMut inside an eoGeneralOp * It does it exactly as class eoSGATransform, i.e. only accepts * quadratic crossover and unary mutation * It was introduced for didactic reasons, but seems to be popular :-) - *****************************************************************************/ -template + * + * @ingroup Combination + */ + template class eoSGAGenOp : public eoGenOp { public: diff --git a/eo/src/eoSGATransform.h b/eo/src/eoSGATransform.h index e1e9c82f5..3707862f8 100644 --- a/eo/src/eoSGATransform.h +++ b/eo/src/eoSGATransform.h @@ -41,6 +41,8 @@ * It does it exactly as class eoSGA, i.e. only accepts * quadratic crossover and unary mutation * It is here mainly for tutorial reasons + * + * @ingroup Combination */ template class eoSGATransform : public eoTransform { @@ -94,7 +96,9 @@ template class eoSGATransform : public eoTransform * i.e. the operators probabilities can be passed as an eoValueParam, * and hence can be modified from outside * It is here mainly for tutorial reasons - *****************************************************************************/ + * + * @ingroup Combination +*/ template class eoDynSGATransform : public eoTransform { public: diff --git a/eo/src/eoSIGContinue.h b/eo/src/eoSIGContinue.h index 2320ebd12..36546fb0a 100644 --- a/eo/src/eoSIGContinue.h +++ b/eo/src/eoSIGContinue.h @@ -35,6 +35,10 @@ #include #include +/** @addtogroup Continuators + * @{ + */ + extern bool existSIGContinue; extern bool call_func; @@ -84,6 +88,7 @@ private: sighandler_t _fct; }; +/** @} */ #endif diff --git a/eo/src/eoSTLFunctor.h b/eo/src/eoSTLFunctor.h index ca8b9233e..c21f161c6 100644 --- a/eo/src/eoSTLFunctor.h +++ b/eo/src/eoSTLFunctor.h @@ -29,6 +29,10 @@ #include "eoFunctor.h" +/** @addtogroup Utilities + * @{ + */ + /** Generic set of classes that wrap an eoF, eoUF or eoBF so that they have the copy semantics the STL functions usually require (i.e. they can be passed @@ -115,4 +119,6 @@ class eoSTLBF : public std::binary_function //! @todo: put automated wrappers here... +/** @} */ #endif + diff --git a/eo/src/eoScalarFitness.h b/eo/src/eoScalarFitness.h index 26bad2737..906c8c8e5 100644 --- a/eo/src/eoScalarFitness.h +++ b/eo/src/eoScalarFitness.h @@ -29,6 +29,10 @@ #include #include +/** @addtogroup Evaluation + * @{ + */ + /** * eoScalarFitness >: * Wraps a scalar fitness values such as a double or int, with the option of @@ -107,4 +111,5 @@ std::istream& operator>>(std::istream& is, eoScalarFitness& f) return is; } +/** @} */ #endif diff --git a/eo/src/eoSecondsElapsedContinue.h b/eo/src/eoSecondsElapsedContinue.h index 08bb991ca..819f7ab5c 100644 --- a/eo/src/eoSecondsElapsedContinue.h +++ b/eo/src/eoSecondsElapsedContinue.h @@ -26,8 +26,11 @@ #define _eoSecondsElapsedContinue_h #include + /** Timed continuator: continues until a number of seconds is used + + @ingroup Continuators */ template< class EOT> class eoSecondsElapsedContinue: public eoContinue diff --git a/eo/src/eoSelect.h b/eo/src/eoSelect.h index 90bfd7dc9..ea5c8592b 100644 --- a/eo/src/eoSelect.h +++ b/eo/src/eoSelect.h @@ -35,6 +35,9 @@ eoSelect selects a number of individuals from the first argument and puts it in the second. To emphasize that it should not try to enlarge the population, the second argument is an eoPopRange, a simple struct that holds a begin and end iterator to the population + +@ingroup Core +@ingroup Selectors */ template class eoSelect : public eoBF&, eoPop&, void> diff --git a/eo/src/eoSelectFactory.h b/eo/src/eoSelectFactory.h index d94a0fa0f..59d2306ac 100644 --- a/eo/src/eoSelectFactory.h +++ b/eo/src/eoSelectFactory.h @@ -1,8 +1,8 @@ // eoSelectFactory.h -// -*- mode: c++; c-indent-level: 4; c++-member-init-indent: 8; comment-column: 35; -*- - +// -*- mode: c++; c-indent-level: 4; c++-member-init-indent: 8; comment-column: 35; -*- + //----------------------------------------------------------------------------- -// EOFactory.h +// EOFactory.h // (c) GeNeura Team, 1998 /* This library is free software; you can redistribute it and/or @@ -25,65 +25,69 @@ #ifndef _EOSELECTFACTORY_H #define _EOSELECTFACTORY_H - -#include -#include -#include + +#include +#include +#include //----------------------------------------------------------------------------- - -/** EO Factory.An instance of the factory class to create selectors, that is, -eoSelect objects -@see eoSelect*/ -template< class EOT> -class eoSelectFactory: public eoFactory > { - -public: - - /// @name ctors and dtors - //{@ - /// constructor - eoSelectFactory( ) {} - - /// destructor - virtual ~eoSelectFactory() {} - //@} - - /** Another factory methods: creates an object from an std::istream, reading from - it whatever is needed to create the object. Usually, the format for the std::istream will be\\ - objectType parameter1 parameter2 ... parametern\\ - */ - virtual eoSelect* make(std::istream& _is) { - eoSelect * selectPtr; - std::string objectTypeStr; - _is >> objectTypeStr; - // All selectors have a rate, the proportion of the original population - float rate; - _is >> rate; - if ( objectTypeStr == "eoTournament") { - // another parameter is necessary - unsigned tSize; - _is >> tSize; - selectPtr = new eoTournament( rate, tSize ); - } else { - if ( objectTypeStr == "eoRandomSelect" ) { - selectPtr = new eoRandomSelect( rate ); - } else { - throw std::runtime_error( "Incorrect selector type" ); - } - } - return selectPtr; - } - - ///@name eoObject methods - //@{ - void printOn( std::ostream& _os ) const {}; - void readFrom( std::istream& _is ){}; - - /** className is inherited */ - //@} - -}; - + +/** EO Factory.An instance of the factory class to create selectors, that is, +eoSelect objects + +@see eoSelect +@ingroup Selectors +@ingroup Utilities +*/ +template< class EOT> +class eoSelectFactory: public eoFactory > { + +public: + + /// @name ctors and dtors + //{@ + /// constructor + eoSelectFactory( ) {} + + /// destructor + virtual ~eoSelectFactory() {} + //@} + + /** Another factory methods: creates an object from an std::istream, reading from + it whatever is needed to create the object. Usually, the format for the std::istream will be\\ + objectType parameter1 parameter2 ... parametern\\ + */ + virtual eoSelect* make(std::istream& _is) { + eoSelect * selectPtr; + std::string objectTypeStr; + _is >> objectTypeStr; + // All selectors have a rate, the proportion of the original population + float rate; + _is >> rate; + if ( objectTypeStr == "eoTournament") { + // another parameter is necessary + unsigned tSize; + _is >> tSize; + selectPtr = new eoTournament( rate, tSize ); + } else { + if ( objectTypeStr == "eoRandomSelect" ) { + selectPtr = new eoRandomSelect( rate ); + } else { + throw std::runtime_error( "Incorrect selector type" ); + } + } + return selectPtr; + } + + ///@name eoObject methods + //@{ + void printOn( std::ostream& _os ) const {}; + void readFrom( std::istream& _is ){}; + + /** className is inherited */ + //@} + +}; + #endif diff --git a/eo/src/eoSelectFromWorth.h b/eo/src/eoSelectFromWorth.h index 4577b822a..e338ea316 100644 --- a/eo/src/eoSelectFromWorth.h +++ b/eo/src/eoSelectFromWorth.h @@ -46,6 +46,8 @@ techniques where it is a std::pair of doubles ... It has to have a < operator it you want to call an existing selector (see selector.h) - but of course you can write the whole thing ... + +@ingroup Selectors */ template class eoSelectFromWorth : public eoSelectOne @@ -86,6 +88,8 @@ protected: /** An instance of eoSelectPerf2Worth that does selection from the Worthes * using a ... determinisitic tournament, yes! + +@ingroup Selectors */ template class eoDetTournamentWorthSelect : public eoSelectFromWorth @@ -123,6 +127,8 @@ private: /** An instance of eoSelectPerf2Worth that does selection from the Worthes * using a ... stochastic tournament, yes! + +@ingroup Selectors */ template class eoStochTournamentWorthSelect : public eoSelectFromWorth @@ -162,6 +168,8 @@ private: /** An instance of eoSelectPerf2Worth that does selection from the Worthes * using a ... roulette wheel selection, yes! + +@ingroup Selectors */ template class eoRouletteWorthSelect : public eoSelectFromWorth diff --git a/eo/src/eoSelectMany.h b/eo/src/eoSelectMany.h index 74bbeee0d..310a918b9 100644 --- a/eo/src/eoSelectMany.h +++ b/eo/src/eoSelectMany.h @@ -40,6 +40,8 @@ It will use an eoHowMnay to determine the number of guys to select, and push them to the back of the destination population. + +@ingroup Selectors */ template class eoSelectMany : public eoSelect diff --git a/eo/src/eoSelectNumber.h b/eo/src/eoSelectNumber.h index 2b5d2a8cd..52cee6622 100644 --- a/eo/src/eoSelectNumber.h +++ b/eo/src/eoSelectNumber.h @@ -37,6 +37,8 @@ It will select a fixed number of individuals and pushes them to the back of the destination population. + +@ingroup Selectors */ template class eoSelectNumber : public eoSelect diff --git a/eo/src/eoSelectOne.h b/eo/src/eoSelectOne.h index dc8a3b1c6..690fbca64 100644 --- a/eo/src/eoSelectOne.h +++ b/eo/src/eoSelectOne.h @@ -36,6 +36,8 @@ of eoSelectOne. @see eoSelectMany, eoSelectRandom, eoDetTournament, eoStochTournament, eoProportional + +@ingroup Selectors */ #if defined(_MSC_VER) && (_MSC_VER < 1300) template diff --git a/eo/src/eoSelectPerc.h b/eo/src/eoSelectPerc.h index c0991d72b..d4aacfdad 100644 --- a/eo/src/eoSelectPerc.h +++ b/eo/src/eoSelectPerc.h @@ -37,6 +37,8 @@ It will select floor(rate*pop.size()) individuals and pushes them to the back of the destination population. + +@ingroup Selectors */ template class eoSelectPerc : public eoSelect diff --git a/eo/src/eoSequentialSelect.h b/eo/src/eoSequentialSelect.h index 9cbfbc401..a30c9248e 100644 --- a/eo/src/eoSequentialSelect.h +++ b/eo/src/eoSequentialSelect.h @@ -48,6 +48,8 @@ worse, or in random order. It is the eoSelectOne equivalent of eoDetSelect - though eoDetSelect always returns individuals from best to worst + +@ingroup Selectors */ template class eoSequentialSelect: public eoSelectOne { @@ -93,6 +95,8 @@ for G3 evolution engine, see Deb, Anad and Joshi, CEC 2002 As eoSequentialSelect, it is an eoSelectOne to be used within the eoEaseyEA algo, but conceptually it should be a global eoSelect, as it selects a bunch of guys in one go (done in the setup function now) + +@ingroup Selectors */ template class eoEliteSequentialSelect: public eoSelectOne { diff --git a/eo/src/eoSharing.h b/eo/src/eoSharing.h index ff2e203b3..b2a58653a 100644 --- a/eo/src/eoSharing.h +++ b/eo/src/eoSharing.h @@ -33,8 +33,11 @@ * Goldberg and Richardson's basic sharing */ -/** A helper class for Sharing - to hold distances */ - class dMatrix : public std::vector +/** A helper class for Sharing - to hold distances + * + * @ingroup Selectors + * */ +class dMatrix : public std::vector { public: // Ctor : sets size @@ -74,6 +77,7 @@ * Goldberg and Richardson's basic sharing * see eoSharingSelect for how to use it * and test/t-eoSharing.cpp for a sample use of both + * @ingroup Selectors */ template class eoSharing : public eoPerf2Worth diff --git a/eo/src/eoSharingSelect.h b/eo/src/eoSharingSelect.h index 40825c971..9fdbfd144 100644 --- a/eo/src/eoSharingSelect.h +++ b/eo/src/eoSharingSelect.h @@ -37,6 +37,7 @@ * rather than the raw fitness (see eoSelectFromWorth.h) * It uses an internal eoSharing object which is * an eoPerf2Worth + * @ingroup Selectors */ template diff --git a/eo/src/eoShiftMutation.h b/eo/src/eoShiftMutation.h index 612cf4d48..9f472360a 100644 --- a/eo/src/eoShiftMutation.h +++ b/eo/src/eoShiftMutation.h @@ -34,6 +34,8 @@ /** * Shift two components of a chromosome. + * + * @ingroup Variators */ template class eoShiftMutation: public eoMonOp { diff --git a/eo/src/eoSigBinaryFlight.h b/eo/src/eoSigBinaryFlight.h index 5bf56e2f7..a172484a3 100644 --- a/eo/src/eoSigBinaryFlight.h +++ b/eo/src/eoSigBinaryFlight.h @@ -39,6 +39,8 @@ * Pi=1 * else * Pi=0 + * + * @ingroup Variators */ template < class POT > class eoSigBinaryFlight:public eoBinaryFlight < POT > { diff --git a/eo/src/eoSocialNeighborhood.h b/eo/src/eoSocialNeighborhood.h index 3c4aae45c..cb8dd9f92 100644 --- a/eo/src/eoSocialNeighborhood.h +++ b/eo/src/eoSocialNeighborhood.h @@ -33,6 +33,8 @@ * Derivated from eoNeighborhood. Just takes relationships into account. * The neighborhood is defined as a list of indices corresponding to particles. * Also contains ONE particle considered as the best of the neighborhood. + * + * @ingroup Selectors */ template < class POT > class eoSocialNeighborhood : public eoNeighborhood { @@ -122,13 +124,3 @@ protected: #endif /* EOSOCIALNEIGHBORHOOD_H_ */ - - - - - - - - - - diff --git a/eo/src/eoStandardFlight.h b/eo/src/eoStandardFlight.h index 3d41c59d3..0c8008be1 100644 --- a/eo/src/eoStandardFlight.h +++ b/eo/src/eoStandardFlight.h @@ -34,6 +34,8 @@ /** Standard flight for particle swarm optimization. Derivated from abstract eoFlight, * just adds the velocities to the current position of the particle * and invalidates its fitness + * + * @ingroup Variators */ template < class POT > class eoStandardFlight:public eoFlight < POT > { diff --git a/eo/src/eoStandardVelocity.h b/eo/src/eoStandardVelocity.h index 73b425739..a66f13d80 100644 --- a/eo/src/eoStandardVelocity.h +++ b/eo/src/eoStandardVelocity.h @@ -40,6 +40,8 @@ * At step t: v(t+1)= w * v(t) + c1 * r1 * ( xbest(t)-x(t) ) + c2 * r2 * ( lbest(t) - x(t) ) * lbest depends on the topology evolved, when using eoStarTopology, lbest corresponds to the * global. Otherwise, lbest is a "local best", i.e the best in a neighborhood. +* +* @ingroup Variators */ template < class POT > class eoStandardVelocity:public eoVelocity < POT > { diff --git a/eo/src/eoStarTopology.h b/eo/src/eoStarTopology.h index db1c6f7b5..ed6ec8ec2 100644 --- a/eo/src/eoStarTopology.h +++ b/eo/src/eoStarTopology.h @@ -36,6 +36,8 @@ * Topology dedicated to "globest best" strategy for particle swarm optimization. * All the particles of the swarm belong to the same and only social neighborhood. * The global best is stored and updated using the eoSocialNeighborhood. +* +* @ingroup Selectors */ template < class POT > class eoStarTopology:public eoTopology { diff --git a/eo/src/eoSteadyFitContinue.h b/eo/src/eoSteadyFitContinue.h index ef78aa127..2422ec1fc 100644 --- a/eo/src/eoSteadyFitContinue.h +++ b/eo/src/eoSteadyFitContinue.h @@ -31,6 +31,8 @@ /** A continuator: does a minimum number of generations, then stops whenever a given number of generations takes place without improvement + + @ingroup Continuators */ template< class EOT> class eoSteadyFitContinue: public eoContinue diff --git a/eo/src/eoStochTournamentSelect.h b/eo/src/eoStochTournamentSelect.h index 69f0376ee..952041e1b 100644 --- a/eo/src/eoStochTournamentSelect.h +++ b/eo/src/eoStochTournamentSelect.h @@ -21,24 +21,21 @@ Contact: todos@geneura.ugr.es, http://geneura.ugr.es Marc.Schoenauer@polytechnique.fr */ -//----------------------------------------------------------------------------- #ifndef eoStochTournamentSelect_h #define eoStochTournamentSelect_h -//----------------------------------------------------------------------------- - #include #include // accumulate #include // eoSelectOne #include // stochastic_tournament -//----------------------------------------------------------------------------- /** eoStochTournamentSelect: a selection method that selects ONE individual by binary stochastic tournament - -MS- 24/10/99 */ -//----------------------------------------------------------------------------- - + -MS- 24/10/99 + + @ingroup Selectors + */ template class eoStochTournamentSelect: public eoSelectOne { public: @@ -67,7 +64,5 @@ private: double Trate; }; -//----------------------------------------------------------------------------- - #endif diff --git a/eo/src/eoStochasticUniversalSelect.h b/eo/src/eoStochasticUniversalSelect.h index 09864057f..cd0c19738 100644 --- a/eo/src/eoStochasticUniversalSelect.h +++ b/eo/src/eoStochasticUniversalSelect.h @@ -34,13 +34,12 @@ #include #include -//----------------------------------------------------------------------------- /** eoStochasticUniversalSelect: select an individual proportional to her stored fitness value, but in contrast with eoStochasticUniversalSelect, get rid of most finite sampling effects by doing all selections in one go, using a single random number. -*/ -//----------------------------------------------------------------------------- + @ingroup Selectors +*/ template class eoStochasticUniversalSelect: public eoSelectOne { public: diff --git a/eo/src/eoSurviveAndDie.h b/eo/src/eoSurviveAndDie.h index f99d646c4..81e2e310c 100644 --- a/eo/src/eoSurviveAndDie.h +++ b/eo/src/eoSurviveAndDie.h @@ -46,6 +46,10 @@ removes them from the first pop argument eoDeterministicSaDReplacement */ +/** @addtogroup Replacors + * @{ + */ + /** eoSurviveAndDie A pure abstract class, to store the howmany's */ @@ -187,5 +191,7 @@ private : }; +/** @} */ #endif + diff --git a/eo/src/eoTimeContinue.h b/eo/src/eoTimeContinue.h index 47f94b671..d49f5ea56 100644 --- a/eo/src/eoTimeContinue.h +++ b/eo/src/eoTimeContinue.h @@ -32,6 +32,8 @@ /** * Termination condition until a running time is reached. + * + * @ingroup Continuators */ template < class EOT > class eoTimeContinue: public eoContinue diff --git a/eo/src/eoTopology.h b/eo/src/eoTopology.h index 531f1fe9d..24bfe8515 100644 --- a/eo/src/eoTopology.h +++ b/eo/src/eoTopology.h @@ -35,6 +35,9 @@ * Defines the interface of a swarm topology. Can be static (usually the case for the social topologies) * or dynamic. It's the same interface for both social and physical topologies. ("social" topology means * social-neighborhood-based toplogy and so on ...) + * + * @ingroup Selectors + * @ingroup Core */ template < class POT > class eoTopology:public eoPop < POT > { diff --git a/eo/src/eoTransform.h b/eo/src/eoTransform.h index 40bc81383..67dd712ae 100644 --- a/eo/src/eoTransform.h +++ b/eo/src/eoTransform.h @@ -31,8 +31,10 @@ //----------------------------------------------------------------------------- /** -eoTransform transforms a population by applying genetic operators on -it. +eoTransform transforms a population by applying genetic operators on it. + +@ingroup Combination +@ingroup Core */ template class eoTransform : public eoUF&, void> diff --git a/eo/src/eoTruncSelect.h b/eo/src/eoTruncSelect.h index 0c64e1622..8f75e2153 100644 --- a/eo/src/eoTruncSelect.h +++ b/eo/src/eoTruncSelect.h @@ -38,6 +38,8 @@ * using eoSelectOne as it's mechanism. * Therefore eoSelectMany needs an eoSelectOne in its ctor * It will use an eoHowMnay to determine the number of guys to keep, + * + * @ingroup Selectors */ template class eoTruncSelect : public eoSelect diff --git a/eo/src/eoTruncatedSelectMany.h b/eo/src/eoTruncatedSelectMany.h index 9cad8dbc4..5e999459d 100644 --- a/eo/src/eoTruncatedSelectMany.h +++ b/eo/src/eoTruncatedSelectMany.h @@ -48,6 +48,8 @@ However, the same result can be obtained by embedding an eoTruncatedSelectOne into an eoSelectMany ... + + @ingroup Selectors */ template class eoTruncatedSelectMany : public eoSelect diff --git a/eo/src/eoTruncatedSelectOne.h b/eo/src/eoTruncatedSelectOne.h index b65739c41..b515cf493 100644 --- a/eo/src/eoTruncatedSelectOne.h +++ b/eo/src/eoTruncatedSelectOne.h @@ -40,6 +40,7 @@ It will perform selection only from the top guys in the population. + @ingroup Selectors */ template class eoTruncatedSelectOne : public eoSelectOne diff --git a/eo/src/eoTwoOptMutation.h b/eo/src/eoTwoOptMutation.h index edeeb2f2e..2cba79e32 100644 --- a/eo/src/eoTwoOptMutation.h +++ b/eo/src/eoTwoOptMutation.h @@ -32,6 +32,8 @@ mak@dhi.dk /** * Especially designed for combinatorial problem such as the TSP. +* +* @ingroup Variators */ template class eoTwoOptMutation: public eoMonOp { diff --git a/eo/src/eoVariableInertiaWeightedVelocity.h b/eo/src/eoVariableInertiaWeightedVelocity.h index e00fb3163..9d039ee6b 100644 --- a/eo/src/eoVariableInertiaWeightedVelocity.h +++ b/eo/src/eoVariableInertiaWeightedVelocity.h @@ -39,6 +39,9 @@ * At step t: v(t+1)= w*v(t) + c1*r1* ( xbest(t)-x(t) ) + c2*r2* ( gbest(t) - x(t) ) * w is updated each time the velocity performer is called. * (ci given and Ri chosen at random in [0;1]). +* +* @ingroup Core +* @ingroup Variators */ template < class POT > class eoVariableInertiaWeightedVelocity:public eoVelocity < POT > { diff --git a/eo/src/eoVariableLengthCrossover.h b/eo/src/eoVariableLengthCrossover.h index 9d604ea87..5ad6de051 100644 --- a/eo/src/eoVariableLengthCrossover.h +++ b/eo/src/eoVariableLengthCrossover.h @@ -36,6 +36,10 @@ Basically, they exchange genes - we need some matching information to apply atom crossover */ +/** @addtogroup Variators + * @{ + */ + /** A helper class for choosing which genes to exchange */ template class eoAtomExchange : public eoBF @@ -344,6 +348,6 @@ private: double rate; }; - - +/** @} */ #endif + diff --git a/eo/src/eoVariableLengthMutation.h b/eo/src/eoVariableLengthMutation.h index 585fc3767..6845ce0c0 100644 --- a/eo/src/eoVariableLengthMutation.h +++ b/eo/src/eoVariableLengthMutation.h @@ -39,6 +39,9 @@ Hence they are in file eoFlOr MonOp.h file (FixedLengthOrdered mutations) */ +/* @addtogroup Variators + * @{ + */ /** Addition of a gene Is inserted at a random position - so can be applied to both @@ -153,6 +156,6 @@ private: eoGeneDelChooser & chooser; }; - - +/** @} */ #endif + diff --git a/eo/src/eoVelocity.h b/eo/src/eoVelocity.h index 3e01efdb1..5d4bdcd23 100644 --- a/eo/src/eoVelocity.h +++ b/eo/src/eoVelocity.h @@ -35,6 +35,8 @@ /** * Abstract class for velocities calculation (particle swarm optimization). * All the velocities must derivated from eoVelocity. + * + * @ingroup Variators */ template < class POT > class eoVelocity:public eoBF < POT &,unsigned , void > { diff --git a/eo/src/eoWeightUpdater.h b/eo/src/eoWeightUpdater.h index 6adfd5f49..656190163 100644 --- a/eo/src/eoWeightUpdater.h +++ b/eo/src/eoWeightUpdater.h @@ -32,6 +32,8 @@ /** * Abstract class for (inertia) weight updater (particle swarm optimization). * Used inside classes extending eoVelocity. + * + * @ingroup Core */ template < class WeightType > class eoWeightUpdater: public eoUF < WeightType &, void > {};