From f478817c6e6c44f3214b528b6491bd7a94b3fdc1 Mon Sep 17 00:00:00 2001 From: Johann Dreo Date: Fri, 5 Nov 2010 15:59:35 +0100 Subject: [PATCH] grouping classes in documentation --- eo/src/eoInt.h | 2 + eo/src/eoIntegerVelocity.h | 2 + eo/src/eoInvalidateOps.h | 2 + eo/src/eoLinearDecreasingWeightUp.h | 2 + eo/src/eoLinearFitScaling.h | 2 + eo/src/eoLinearTopology.h | 2 + eo/src/eoMGGReplacement.h | 1 + eo/src/eoMerge.h | 7 ++ eo/src/eoMergeReduce.h | 4 + eo/src/eoNeighborhood.h | 2 + eo/src/eoOneToOneBreeder.h | 6 +- eo/src/eoOp.h | 1 + eo/src/eoOpContainer.h | 4 + eo/src/eoOpSelMason.h | 9 +- eo/src/eoOrderXover.h | 2 + eo/src/eoPerf2Worth.h | 10 +- eo/src/eoPeriodicContinue.h | 29 ++--- eo/src/eoPersistent.cpp | 1 - eo/src/eoPop.h | 6 +- eo/src/eoPopEvalFunc.h | 6 + eo/src/eoPopulator.h | 6 +- eo/src/eoPropGAGenOp.h | 6 +- eo/src/eoProportionalSelect.h | 6 +- eo/src/eoRandomRealWeightUp.h | 2 + eo/src/eoRandomSelect.h | 22 ++-- eo/src/eoRanking.h | 2 + eo/src/eoRankingSelect.h | 3 +- eo/src/eoRealBoundModifier.h | 14 ++- eo/src/eoRealParticle.h | 2 + eo/src/eoReduce.h | 15 ++- eo/src/eoReduceMerge.h | 4 + eo/src/eoReduceMergeReduce.h | 2 +- eo/src/eoReduceSplit.h | 5 + eo/src/eoReplacement.h | 20 ++-- eo/src/eoRingTopology.h | 2 + eo/src/eoSGAGenOp.h | 8 +- eo/src/eoSGATransform.h | 6 +- eo/src/eoSIGContinue.h | 5 + eo/src/eoSTLFunctor.h | 6 + eo/src/eoScalarFitness.h | 5 + eo/src/eoSecondsElapsedContinue.h | 3 + eo/src/eoSelect.h | 3 + eo/src/eoSelectFactory.h | 126 +++++++++++---------- eo/src/eoSelectFromWorth.h | 8 ++ eo/src/eoSelectMany.h | 2 + eo/src/eoSelectNumber.h | 2 + eo/src/eoSelectOne.h | 2 + eo/src/eoSelectPerc.h | 2 + eo/src/eoSequentialSelect.h | 4 + eo/src/eoSharing.h | 8 +- eo/src/eoSharingSelect.h | 1 + eo/src/eoShiftMutation.h | 2 + eo/src/eoSigBinaryFlight.h | 2 + eo/src/eoSocialNeighborhood.h | 12 +- eo/src/eoStandardFlight.h | 2 + eo/src/eoStandardVelocity.h | 2 + eo/src/eoStarTopology.h | 2 + eo/src/eoSteadyFitContinue.h | 2 + eo/src/eoStochTournamentSelect.h | 13 +-- eo/src/eoStochasticUniversalSelect.h | 5 +- eo/src/eoSurviveAndDie.h | 6 + eo/src/eoTimeContinue.h | 2 + eo/src/eoTopology.h | 3 + eo/src/eoTransform.h | 6 +- eo/src/eoTruncSelect.h | 2 + eo/src/eoTruncatedSelectMany.h | 2 + eo/src/eoTruncatedSelectOne.h | 1 + eo/src/eoTwoOptMutation.h | 2 + eo/src/eoVariableInertiaWeightedVelocity.h | 3 + eo/src/eoVariableLengthCrossover.h | 8 +- eo/src/eoVariableLengthMutation.h | 7 +- eo/src/eoVelocity.h | 2 + eo/src/eoWeightUpdater.h | 2 + 73 files changed, 326 insertions(+), 164 deletions(-) diff --git a/eo/src/eoInt.h b/eo/src/eoInt.h index 2742edaa..e4f35079 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 76f7161a..1802dab5 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 4643c727..aa5a1853 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 eb1af0be..87f48942 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 e5f4c819..75598c93 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 4c61bf00..99457b67 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 55eaaa54..a625e1e8 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 0e359ae5..1e2b2bf4 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 f0c6a1b5..b4c71752 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 79857838..fa0edd3f 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 cd18edd1..4036377c 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 f263ef69..849a6da0 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 6a31ced9..70252a49 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 6c1d8092..02f92777 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 3d0e8939..211af69b 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 35d2f28e..9f1746ec 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 7b47af6e..c96391c8 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 253c5803..63e906ca 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 b2d58fac..7eb726c5 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 e0327922..9f5fca59 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 34b4f236..eaf8f841 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 e4305e29..44ccc7a5 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 8c01b750..c5a895ff 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 ff7db755..b929504c 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 6569207b..6d99f17e 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 def90dd8..ec812006 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 fd5619a9..465dca56 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 d9fa099e..e9d21c4c 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 96642c23..14326558 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 9d5ff97b..8783c59f 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 52088cd0..03e025ac 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 05854ea7..41629267 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 915de474..758f48bd 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 ca2caa0e..972aa61a 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 bd5ba7b5..352a6e2a 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 a6533f07..922a46ca 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 e1e9c82f..3707862f 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 2320ebd1..36546fb0 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 ca8b9233..c21f161c 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 26bad273..906c8c8e 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 08bb991c..819f7ab5 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 90bfd7dc..ea5c8592 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 d94a0fa0..59d2306a 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 4577b822..e338ea31 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 74bbeee0..310a918b 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 2b5d2a8c..52cee662 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 dc8a3b1c..690fbca6 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 c0991d72..d4aacfda 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 9cbfbc40..a30c9248 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 ff2e203b..b2a58653 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 40825c97..9fdbfd14 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 612cf4d4..9f472360 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 5bf56e2f..a172484a 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 3c4aae45..cb8dd9f9 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 3d41c59d..0c8008be 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 73b42573..a66f13d8 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 db1c6f7b..ed6ec8ec 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 ef78aa12..2422ec1f 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 69f0376e..952041e1 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 09864057..cd0c1973 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 f99d646c..81e2e310 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 47f94b67..d49f5ea5 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 531f1fe9..24bfe851 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 40bc8138..67dd712a 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 0c64e162..8f75e215 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 9cad8dbc..5e999459 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 b65739c4..b515cf49 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 edeeb2f2..2cba79e3 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 e00fb316..9d039ee6 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 9d604ea8..5ad6de05 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 585fc376..6845ce0c 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 3e01efdb..5d4bdcd2 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 6adfd5f4..65619016 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 > {};