From 8e70cbea01f3229fa04bcac8b29b32b99bfc2934 Mon Sep 17 00:00:00 2001 From: Johann Dreo Date: Fri, 5 Nov 2010 11:26:04 +0100 Subject: [PATCH] grouping classes in documentation --- eo/src/apply.h | 2 ++ eo/src/eoBinaryFlight.h | 2 ++ eo/src/eoBitParticle.h | 2 ++ eo/src/eoCloneOps.h | 4 ++++ eo/src/eoCombinedContinue.h | 3 ++- eo/src/eoConstrictedVariableWeightVelocity.h | 2 ++ eo/src/eoConstrictedVelocity.h | 2 ++ eo/src/eoContinue.h | 11 +++++++++++ eo/src/eoCounter.h | 2 ++ eo/src/eoCtrlCContinue.h | 7 ++++++- eo/src/eoDetSelect.h | 2 ++ eo/src/eoDetTournamentSelect.h | 6 +++--- eo/src/eoDistribUpdater.h | 2 +- eo/src/eoDistribution.h | 2 ++ eo/src/eoDualFitness.h | 7 ++++++- eo/src/eoEvalContinue.h | 2 ++ eo/src/eoEvalCounterThrowException.h | 2 ++ eo/src/eoEvalFunc.h | 12 +++++++++--- eo/src/eoEvalFuncCounter.h | 5 +++-- eo/src/eoEvalFuncCounterBounder.h | 17 ++++++++++++++--- eo/src/eoEvalFuncPtr.h | 2 ++ eo/src/eoEvalTimeThrowException.h | 7 +++++++ eo/src/eoExceptions.h | 4 ++++ eo/src/eoExtendedVelocity.h | 2 ++ eo/src/eoFactory.h | 5 ++++- eo/src/eoFitContinue.h | 9 ++++----- eo/src/eoFitnessScalingSelect.h | 2 ++ eo/src/eoFixedInertiaWeightedVelocity.h | 2 ++ eo/src/eoFlOrBinOp.h | 5 +++++ eo/src/eoFlOrMonOp.h | 5 +++++ eo/src/eoFlOrQuadOp.h | 5 +++++ eo/src/eoFlight.h | 3 ++- eo/src/eoFunctor.h | 5 +++++ eo/src/eoFunctorStore.h | 2 ++ eo/src/eoG3Replacement.h | 2 +- eo/src/eoGaussRealWeightUp.h | 2 ++ eo/src/eoGenContinue.h | 2 ++ eo/src/eoGenOp.h | 3 +++ eo/src/eoGeneralBreeder.h | 2 ++ 39 files changed, 140 insertions(+), 23 deletions(-) diff --git a/eo/src/apply.h b/eo/src/apply.h index 54cf162e..0eb3484e 100644 --- a/eo/src/apply.h +++ b/eo/src/apply.h @@ -31,6 +31,8 @@ /** Applies a unary function to a std::vector of things. + + @ingroup Utilities */ template void apply(eoUF& _proc, std::vector& _pop) diff --git a/eo/src/eoBinaryFlight.h b/eo/src/eoBinaryFlight.h index 425959e0..9672bd3f 100644 --- a/eo/src/eoBinaryFlight.h +++ b/eo/src/eoBinaryFlight.h @@ -34,6 +34,8 @@ /** Abstract class for binary flight of particle swarms. Positions are updated but are expected to be binary. * A function must be used to decide, according to continuous velocities, of the * new positions (0,1 ... ?) + * + * @ingroup Core */ template < class POT > class eoBinaryFlight:public eoFlight < POT >{}; diff --git a/eo/src/eoBitParticle.h b/eo/src/eoBitParticle.h index 9e21b541..87f98aa1 100644 --- a/eo/src/eoBitParticle.h +++ b/eo/src/eoBitParticle.h @@ -31,6 +31,8 @@ /** eoBitParticle: Implementation of a bit-coded particle (swarm optimization). * Positions and best positions are 0 or 1 but the velocity is a vector of double. + * + * @ingroup Bitstring */ template < class FitT> class eoBitParticle: public eoVectorParticle diff --git a/eo/src/eoCloneOps.h b/eo/src/eoCloneOps.h index 4af49c62..bdb9f041 100644 --- a/eo/src/eoCloneOps.h +++ b/eo/src/eoCloneOps.h @@ -35,6 +35,9 @@ * within the eoGenOp framework * eoMonCloneOp will probably be useful as the copy operator * eoBinCloneOp will certainly never been used - but let's be complete :-) + * + * @addtogroup Core + * @{ */ /** @@ -76,4 +79,5 @@ virtual bool operator()(EOT& , EOT& ) {return false;} }; #endif +/** @} */ diff --git a/eo/src/eoCombinedContinue.h b/eo/src/eoCombinedContinue.h index ec644521..2788f415 100644 --- a/eo/src/eoCombinedContinue.h +++ b/eo/src/eoCombinedContinue.h @@ -36,8 +36,9 @@ and allow to easily handle more than 2 continuators 02/2003 Ramón Casero Cañas - added the removeLast() method -*/ +@ingroup Combination +*/ template< class EOT> class eoCombinedContinue: public eoContinue { public: diff --git a/eo/src/eoConstrictedVariableWeightVelocity.h b/eo/src/eoConstrictedVariableWeightVelocity.h index 76a000ff..64139ea5 100644 --- a/eo/src/eoConstrictedVariableWeightVelocity.h +++ b/eo/src/eoConstrictedVariableWeightVelocity.h @@ -39,6 +39,8 @@ * At step t: v(t+1)= K * ( 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 and K is fixed * (ci given and Ri chosen at random in [0;1]). +* +* @ingroup Variators */ template < class POT > class eoConstrictedVariableWeightVelocity:public eoVelocity < POT > { diff --git a/eo/src/eoConstrictedVelocity.h b/eo/src/eoConstrictedVelocity.h index ba3eb4f6..d71e29b0 100644 --- a/eo/src/eoConstrictedVelocity.h +++ b/eo/src/eoConstrictedVelocity.h @@ -40,6 +40,8 @@ * C is fixed for all the particles and all the generations. * Default C = 2 * k / abs(2 - P - sqrt (P*(P-4))) * (ci and C given;P=c1*r1 + c2*r2 ; Ri chosen at random * in [0;1]) +* +* @ingroup Variators */ template < class POT > class eoConstrictedVelocity:public eoVelocity < POT > { diff --git a/eo/src/eoContinue.h b/eo/src/eoContinue.h index 692d01f3..c49e8c95 100644 --- a/eo/src/eoContinue.h +++ b/eo/src/eoContinue.h @@ -29,9 +29,20 @@ #include #include +/** @defgroup Continuators Stopping criteria + * + * A stopping criterion is called a "continue". This is a functor that is called at each generation end + * and that return true if one should stop the search. + * + * @ingroup Utilities + */ + /** Termination condition for the genetic algorithm * Takes the population as input, returns true for continue, * false for termination + * + * @ingroup Continuators + * @ingroup Core */ template< class EOT> class eoContinue : public eoUF&, bool>, public eoPersistent diff --git a/eo/src/eoCounter.h b/eo/src/eoCounter.h index 05e08b21..cb0b57cf 100644 --- a/eo/src/eoCounter.h +++ b/eo/src/eoCounter.h @@ -36,6 +36,8 @@ use this class instead of it. It is derived from eoValueParam so you can add it to a monitor. + + @ingroup Utilities */ template class eoProcedureCounter : public Procedure, public eoValueParam diff --git a/eo/src/eoCtrlCContinue.h b/eo/src/eoCtrlCContinue.h index 797e294a..b102a18e 100644 --- a/eo/src/eoCtrlCContinue.h +++ b/eo/src/eoCtrlCContinue.h @@ -33,6 +33,11 @@ #include #include +/** + * @addtogroup Continuators + * @{ + */ + extern bool arret_demande, existCtrlCContinue; extern void signal_handler( int sig ); @@ -78,5 +83,5 @@ public: #endif +/** @} */ - // of MSVC comment-out diff --git a/eo/src/eoDetSelect.h b/eo/src/eoDetSelect.h index 9f7cb878..2ad6cde0 100644 --- a/eo/src/eoDetSelect.h +++ b/eo/src/eoDetSelect.h @@ -35,6 +35,8 @@ //----------------------------------------------------------------------------- /** eoDetSelect selects many individuals determinisctically + * + * @ingroup Selectors */ template class eoDetSelect : public eoSelect diff --git a/eo/src/eoDetTournamentSelect.h b/eo/src/eoDetTournamentSelect.h index 7042a339..81bbaba1 100644 --- a/eo/src/eoDetTournamentSelect.h +++ b/eo/src/eoDetTournamentSelect.h @@ -36,12 +36,12 @@ #include #include -//----------------------------------------------------------------------------- /** eoDetTournamentSelect: a selection method that selects ONE individual by deterministic tournament - -MS- 24/10/99 */ -//----------------------------------------------------------------------------- + -MS- 24/10/99 + @ingroup Selectors + */ template class eoDetTournamentSelect: public eoSelectOne { public: diff --git a/eo/src/eoDistribUpdater.h b/eo/src/eoDistribUpdater.h index 1749994f..6166e733 100644 --- a/eo/src/eoDistribUpdater.h +++ b/eo/src/eoDistribUpdater.h @@ -37,8 +37,8 @@ * * It takes one distribution and updates it according to one population * + * @ingroup Core */ - template class eoDistribUpdater : public eoBF &, eoPop &, void> diff --git a/eo/src/eoDistribution.h b/eo/src/eoDistribution.h index 9facd916..1f38ab94 100644 --- a/eo/src/eoDistribution.h +++ b/eo/src/eoDistribution.h @@ -39,6 +39,8 @@ * * The instances will probably be eoValueParam of some kind * see eoPBILDistrib.h + * + * @ingroup Core */ template diff --git a/eo/src/eoDualFitness.h b/eo/src/eoDualFitness.h index 946f95c6..0ab99413 100644 --- a/eo/src/eoDualFitness.h +++ b/eo/src/eoDualFitness.h @@ -30,7 +30,11 @@ Authors: #include #include // for std::pair -//! A fitness class that permits to compare feasible and unfeasible individuals. It guaranties that a feasible individual will always be better than an unfeasible one. +/** @addtogroup Evaluation + * @{ + */ + +//! A fitness class that permits to compare feasible and unfeasible individuals and guaranties that a feasible individual will always be better than an unfeasible one. /** * Use this class as fitness if you have some kind of individuals * that must be always considered as better than others while having the same fitness type. @@ -232,5 +236,6 @@ typedef eoDualFitness > eoMinimizingDualFitness; template< class EOT> bool eoIsFeasible ( const EOT & sol ) { return sol.fitness().is_feasible(); } +/** @} */ #endif // _eoDualFitness_h_ diff --git a/eo/src/eoEvalContinue.h b/eo/src/eoEvalContinue.h index c8af79fe..05ac2f0a 100644 --- a/eo/src/eoEvalContinue.h +++ b/eo/src/eoEvalContinue.h @@ -31,6 +31,8 @@ /** * Continues until a number of evaluations has been made + * + * @ingroup Continuators */ template< class EOT> class eoEvalContinue: public eoContinue diff --git a/eo/src/eoEvalCounterThrowException.h b/eo/src/eoEvalCounterThrowException.h index bf19e73e..133d3afb 100644 --- a/eo/src/eoEvalCounterThrowException.h +++ b/eo/src/eoEvalCounterThrowException.h @@ -41,6 +41,8 @@ The class first call the evaluation function, then check the number of times it has been called. If the maximum number of evaluation has been reached, it throw an eoMaxEvalException. You can catch this exception from your main function, so as to stop everything properly. + +@ingroup Evaluation */ template < typename EOT > class eoEvalCounterThrowException : public eoEvalFuncCounter< EOT > diff --git a/eo/src/eoEvalFunc.h b/eo/src/eoEvalFunc.h index 3dfaeba0..275c5185 100644 --- a/eo/src/eoEvalFunc.h +++ b/eo/src/eoEvalFunc.h @@ -27,17 +27,23 @@ #include +/** @defgroup Evaluation Evaluation + * @ingroup Operators + */ + /** Evaluate: takes one EO and sets its "fitness" property - * returning this fitness also. That is why EOT is passed by - * non-const reference: it must be altered within evaluate.\\ + returning this fitness also. That is why EOT is passed by + non-const reference: it must be altered within evaluate.\\ The requirements on the types with which this class is to be instantiated with are null, or else, they depend on the particular class it's going to be applied to; EO does not impose any requirement on it. If you subclass this abstract class, and use it to evaluate an EO, the requirements on this EO will depend on the evaluator. - */ + @ingroup Evaluation + @ingroup Core + */ template class eoEvalFunc : public eoUF { public : diff --git a/eo/src/eoEvalFuncCounter.h b/eo/src/eoEvalFuncCounter.h index b8532e2a..55973d06 100644 --- a/eo/src/eoEvalFuncCounter.h +++ b/eo/src/eoEvalFuncCounter.h @@ -31,8 +31,9 @@ #include /** -Counts the number of evaluations actually performed, thus checks first -if it has to evaluate.. etc. +Counts the number of evaluations actually performed. + +@ingroup Evaluation */ template class eoEvalFuncCounter : public eoEvalFunc, public eoValueParam { diff --git a/eo/src/eoEvalFuncCounterBounder.h b/eo/src/eoEvalFuncCounterBounder.h index d9d83c18..68c9770c 100644 --- a/eo/src/eoEvalFuncCounterBounder.h +++ b/eo/src/eoEvalFuncCounterBounder.h @@ -4,6 +4,13 @@ #include #include +/** @addtogroup Evaluation + * @{ + */ + +/** The exception raised by eoEvalFuncCounterBounder + * when the maximum number of allowed evaluations is reached. + */ class eoEvalFuncCounterBounderException : public std::exception { public: @@ -20,9 +27,12 @@ private: unsigned long _threshold; }; -/** -Counts the number of evaluations actually performed, thus checks first -if it has to evaluate.. etc. +/** Counts the number of evaluations actually performed and throw an eoEvalFuncCounterBounderException + * when the maximum number of allowed evaluations is reached. + * + * This eval counter permits to stop a search during a generation, without waiting for a continue to be + * checked at the end of the loop. Useful if you have 10 individuals and 10 generations, + * but want to stop after 95 evaluations. */ template < typename EOT > class eoEvalFuncCounterBounder : public eoEvalFuncCounter< EOT > @@ -53,4 +63,5 @@ private : unsigned long _threshold; }; +/** @} */ #endif diff --git a/eo/src/eoEvalFuncPtr.h b/eo/src/eoEvalFuncPtr.h index fd98e4e3..d493b9b0 100644 --- a/eo/src/eoEvalFuncPtr.h +++ b/eo/src/eoEvalFuncPtr.h @@ -34,6 +34,8 @@ * takes an existing function pointer and converts it into a evaluation * function class. That way, old style C or C++ functions can be adapted to EO * function classes. + * + * @ingroup Evaluation */ #ifdef _MSC_VER template< class EOT, class FitT = EOT::Fitness, class FunctionArg = const EOT& > diff --git a/eo/src/eoEvalTimeThrowException.h b/eo/src/eoEvalTimeThrowException.h index 3b0bc14f..752fafba 100644 --- a/eo/src/eoEvalTimeThrowException.h +++ b/eo/src/eoEvalTimeThrowException.h @@ -25,6 +25,13 @@ Johann Dréo #include +/** Check at each evaluation if a given tie contract has been reached. + * + * Throw an eoMaxTimeException if the given max time has been reached. + * Usefull if you want to end the search independently of generations. + * + * @ingroup Evaluation + */ template< class EOT > class eoEvalTimeThrowException : public eoEvalFuncCounter< EOT > { diff --git a/eo/src/eoExceptions.h b/eo/src/eoExceptions.h index 3e595c06..bcccee2a 100644 --- a/eo/src/eoExceptions.h +++ b/eo/src/eoExceptions.h @@ -35,6 +35,8 @@ class eoMaxException : public std::exception {}; An error that signals that a maximum elapsed time has been reached. Thrown by @see eoEvalTimeThrowException + +@ingroup Evaluation */ class eoMaxTimeException : public eoMaxException { @@ -58,6 +60,8 @@ private: An error that signals that a maximum number of evaluations has been reached. Thrown by @see eoEvalEvalThrowException + +@ingroup Evaluation */ class eoMaxEvalException : public eoMaxException { diff --git a/eo/src/eoExtendedVelocity.h b/eo/src/eoExtendedVelocity.h index 1a39c2ce..687a11a8 100644 --- a/eo/src/eoExtendedVelocity.h +++ b/eo/src/eoExtendedVelocity.h @@ -39,6 +39,8 @@ * At step t: v(t+1)= w * v(t) + c1 * r1 * ( xbest(t)-x(t) ) + c2 * r2 * ( lbest(t) - x(t) ) + c3 * r3 * ( gbest(t) - x(t) ) * It includes both a "topology" best and a global best in the social knowledge. Each topology * provides a method to retrieve the global best <=> the best of all the neighborhood the topology contains. +* +* @ingroup Variators */ template < class POT > class eoExtendedVelocity:public eoVelocity < POT > { diff --git a/eo/src/eoFactory.h b/eo/src/eoFactory.h index 13864f03..7e02d124 100644 --- a/eo/src/eoFactory.h +++ b/eo/src/eoFactory.h @@ -37,7 +37,10 @@ or whatever; but the instance class should be the parent class from which all th object that are going to be created descend. This class basically defines an interface, as usual. The base factory class for each hierarchy should be redefined every time a new object is added to the hierarchy, which is not too good, but in any case, some code would -have to be modified*/ +have to be modified + +@ingroup Utilities +*/ template class eoFactory: public eoObject { diff --git a/eo/src/eoFitContinue.h b/eo/src/eoFitContinue.h index 8cf1c9f3..96401451 100644 --- a/eo/src/eoFitContinue.h +++ b/eo/src/eoFitContinue.h @@ -29,13 +29,12 @@ #include /** -Fitness continuation: +Continues until the optimum fitness level is reached. - Continues until the optimum fitness level is reached. +All types which derive from eoScalarFitness is able to compare well via the operator override ( <, >, <=, ...) + + @ingroup Continuators */ - -//! all types which derive from eoScalarFitness is able to compare well via the operator override ( <, >, <=, ...) - template< class EOT> class eoFitContinue: public eoContinue { public: diff --git a/eo/src/eoFitnessScalingSelect.h b/eo/src/eoFitnessScalingSelect.h index 0b3ec273..7ea61607 100644 --- a/eo/src/eoFitnessScalingSelect.h +++ b/eo/src/eoFitnessScalingSelect.h @@ -35,6 +35,8 @@ /** eoFitnessScalingSelect: select an individual proportional to the * linearly scaled fitness that is computed by the private * eoLinearFitScaling object + * + * @ingroup Selectors */ template class eoFitnessScalingSelect: public eoRouletteWorthSelect diff --git a/eo/src/eoFixedInertiaWeightedVelocity.h b/eo/src/eoFixedInertiaWeightedVelocity.h index 6d748d18..26848a59 100644 --- a/eo/src/eoFixedInertiaWeightedVelocity.h +++ b/eo/src/eoFixedInertiaWeightedVelocity.h @@ -38,6 +38,8 @@ * At step t+1 : v(t+1)= w * v(t) + c1*r1 * (xbest(t)-x(t)) + c2*r2 * (gbest(t) - x(t)) * w is fixed for all the particles and all the generations. * (ci and w given; Ri chosen at random * in [0;1]) +* +* @ingroup Variators */ template < class POT > class eoFixedInertiaWeightedVelocity:public eoVelocity < POT > { diff --git a/eo/src/eoFlOrBinOp.h b/eo/src/eoFlOrBinOp.h index 2dda394d..dd1ff617 100644 --- a/eo/src/eoFlOrBinOp.h +++ b/eo/src/eoFlOrBinOp.h @@ -29,6 +29,10 @@ #include #include +/** @addtogroup Variators + * @{ + */ + /** Generic eoBinOps on fixed length genotypes. * Contains exchange crossovers (1pt and uniform) * and crossovers that applies an Atom crossover @@ -215,5 +219,6 @@ public : }; +/** @} */ #endif diff --git a/eo/src/eoFlOrMonOp.h b/eo/src/eoFlOrMonOp.h index ae6f7d74..102acc11 100644 --- a/eo/src/eoFlOrMonOp.h +++ b/eo/src/eoFlOrMonOp.h @@ -30,6 +30,10 @@ #include #include +/** @addtogroup Variators + * @{ + */ + /** Base classes for generic mutations on fixed length chromosomes. * Contains 2 classes that both use an atomic mutation * eoFlOrAllMutation applies the atom mutation to all components with given rate @@ -114,5 +118,6 @@ private: eoMonOp & atomMutation; // the atom mutation }; +/** @} */ #endif diff --git a/eo/src/eoFlOrQuadOp.h b/eo/src/eoFlOrQuadOp.h index 0e4b9a46..f9c0373c 100644 --- a/eo/src/eoFlOrQuadOp.h +++ b/eo/src/eoFlOrQuadOp.h @@ -29,6 +29,10 @@ #include #include +/** @addtogroup Variators + * @{ + */ + /** Generic eoQuadOps on fixed length genotypes. * Contains exchange crossovers (1pt and uniform) * and crossovers that applies an Atom crossover @@ -209,5 +213,6 @@ public : }; +/** @} */ #endif diff --git a/eo/src/eoFlight.h b/eo/src/eoFlight.h index 18b550f9..9af813a2 100644 --- a/eo/src/eoFlight.h +++ b/eo/src/eoFlight.h @@ -32,8 +32,9 @@ /** Abstract class for particle swarm optimization flight. * All the flights must derivated from eoFlight. +* +* @ingroup Variators */ - template < class POT > class eoFlight:public eoUF < POT &, void > { public: diff --git a/eo/src/eoFunctor.h b/eo/src/eoFunctor.h index 4e905c79..7b14d55f 100644 --- a/eo/src/eoFunctor.h +++ b/eo/src/eoFunctor.h @@ -29,6 +29,10 @@ #include +/** @ddtogroup Core + * @{ + */ + /** Base class for functors to get a nice hierarchy diagram That's actually quite an understatement as it does quite a bit more than @@ -173,5 +177,6 @@ eoFunctorBase::binary_function_tag functor_category(const eoBF&) return eoFunctorBase::binary_function_tag(); } +/** @} */ #endif diff --git a/eo/src/eoFunctorStore.h b/eo/src/eoFunctorStore.h index 18e15ae4..c609637b 100644 --- a/eo/src/eoFunctorStore.h +++ b/eo/src/eoFunctorStore.h @@ -35,6 +35,8 @@ class eoFunctorBase; eoFunctorStore is a class that stores functors that are allocated on the heap. This class can be used in factories to store allocated memory for dynamically created functors. + + @ingroup Utilities */ class eoFunctorStore { diff --git a/eo/src/eoG3Replacement.h b/eo/src/eoG3Replacement.h index 7e7950f7..aab7866f 100644 --- a/eo/src/eoG3Replacement.h +++ b/eo/src/eoG3Replacement.h @@ -44,8 +44,8 @@ eoG3Replacement is an eoReplacement: - select best N of this merged population - put them back into parent population +@ingroup Replacors */ - template class eoG3Replacement : public eoReplacement { diff --git a/eo/src/eoGaussRealWeightUp.h b/eo/src/eoGaussRealWeightUp.h index bffcb62d..0da27b34 100644 --- a/eo/src/eoGaussRealWeightUp.h +++ b/eo/src/eoGaussRealWeightUp.h @@ -34,6 +34,8 @@ /** * Update an inertia weight by assigning it a Gaussian randomized value * (used for the velocity in particle swarm optimization). + * + * @ingroup Variators */ class eoGaussRealWeightUp:public eoWeightUpdater { diff --git a/eo/src/eoGenContinue.h b/eo/src/eoGenContinue.h index 3619a520..4dbdd206 100644 --- a/eo/src/eoGenContinue.h +++ b/eo/src/eoGenContinue.h @@ -31,6 +31,8 @@ /** Generational continuator: continues until a number of generations is reached + + @ingroup Continuators */ template< class EOT> class eoGenContinue: public eoContinue, public eoValueParam diff --git a/eo/src/eoGenOp.h b/eo/src/eoGenOp.h index f2bea9c5..e3964905 100644 --- a/eo/src/eoGenOp.h +++ b/eo/src/eoGenOp.h @@ -38,6 +38,9 @@ thanks to the friend class eoPopulator @author Maarten Keijzer @version 0.0 + +@ingroup Core +@ingroup Variators */ //@{ diff --git a/eo/src/eoGeneralBreeder.h b/eo/src/eoGeneralBreeder.h index db46ab90..34d9220d 100644 --- a/eo/src/eoGeneralBreeder.h +++ b/eo/src/eoGeneralBreeder.h @@ -41,6 +41,8 @@ /** Base class for breeders using generalized operators. + + @ingroup Combination */ template class eoGeneralBreeder: public eoBreed