grouping classes in documentation

eo/src/apply.h

@@ -31,6 +31,8 @@
 
 /**
   Applies a unary function to a std::vector of things.
+
+  @ingroup Utilities
 */
 template <class EOT>
 void apply(eoUF<EOT&, void>& _proc, std::vector<EOT>& _pop)

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 >{};
 

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<FitT,bool,double>
 

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
+/** @} */
 

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<EOT> {
 public:

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 >
 {

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 >
 {

eo/src/eoContinue.h

@@ -29,9 +29,20 @@
 #include <eoPop.h>
 #include <eoPersistent.h>
 
+/** @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<const eoPop<EOT>&, bool>, public eoPersistent 

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 Procedure>
 class eoProcedureCounter : public Procedure, public eoValueParam<unsigned long>

eo/src/eoCtrlCContinue.h

@@ -33,6 +33,11 @@
 #include <signal.h>
 #include <eoContinue.h>
 
+/**
+ * @addtogroup Continuators
+ * @{
+ */
+
 extern bool arret_demande, existCtrlCContinue;
 
 extern void signal_handler( int sig );
@@ -78,5 +83,5 @@ public:
 
 
 #endif
+/** @} */
 
- // of MSVC comment-out

eo/src/eoDetSelect.h

@@ -35,6 +35,8 @@
 //-----------------------------------------------------------------------------
 
 /** eoDetSelect selects many individuals determinisctically
+ *
+ * @ingroup Selectors
 */
 template<class EOT>
 class eoDetSelect : public eoSelect<EOT>

eo/src/eoDetTournamentSelect.h

@@ -36,12 +36,12 @@
 #include <utils/eoLogger.h>
 #include <utils/selectors.h>
 
-//-----------------------------------------------------------------------------
 /** eoDetTournamentSelect: a selection method that selects ONE individual by
  deterministic tournament 
- -MS- 24/10/99 */
-//-----------------------------------------------------------------------------
+ -MS- 24/10/99
 
+ @ingroup Selectors
+ */
 template <class EOT> class eoDetTournamentSelect: public eoSelectOne<EOT>
 {
  public:

eo/src/eoDistribUpdater.h

@@ -37,8 +37,8 @@
  *
  * It takes one distribution and updates it according to one population
  *
+ * @ingroup Core
 */
-
 template <class EOT>
 class eoDistribUpdater :  
   public eoBF<eoDistribution<EOT> &, eoPop<EOT> &, void>

eo/src/eoDistribution.h

@@ -39,6 +39,8 @@
  *
  * The instances will probably be eoValueParam of some kind
  *    see eoPBILDistrib.h
+ *
+ *  @ingroup Core
 */
 
 template <class EOT>

eo/src/eoDualFitness.h

@@ -30,7 +30,11 @@ Authors:
 #include <iostream>
 #include <utility> // 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<double, std::greater<double> > eoMinimizingDualFitness;
 template< class EOT>
 bool eoIsFeasible ( const EOT & sol ) { return sol.fitness().is_feasible(); }
 
+/** @} */
 #endif // _eoDualFitness_h_
 

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<EOT>

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 >

eo/src/eoEvalFunc.h

@@ -27,17 +27,23 @@
 
 #include <eoFunctor.h>
 
+/** @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 EOT> class eoEvalFunc : public eoUF<EOT&, void>
 {
     public :

eo/src/eoEvalFuncCounter.h

@@ -31,8 +31,9 @@
 #include <utils/eoParam.h>
 
 /** 
-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 EOT> class eoEvalFuncCounter : public eoEvalFunc<EOT>, public eoValueParam<unsigned long>
 {

eo/src/eoEvalFuncCounterBounder.h

@@ -4,6 +4,13 @@
 #include <eoEvalFunc.h>
 #include <utils/eoParam.h>
 
+/** @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