grouping algorithms in a module of the doc

eo/src/eoAlgo.h

@@ -29,11 +29,24 @@
 #include <eoFunctor.h>
 
 /**
-    This is a generic class for population-transforming algorithms. There
+  @defgroup Algorithms Algorithms
+
+  In EO, an algorithm is a functor that takes one or several solutions to an optimization 
+  problem as arguments, and iteratively modify them with the help of operators.
+
+  Generally, an EO object is built by assembling together @ref Operators in an algorithm instance,
+  and then calling the algorithm's operator() on an initial @ref Population. The algorithm will then
+  manipulate the solutions within the population to search for the problem's optimum.
+*/
+
+/**
+    This is the base class for population-transforming algorithms. There
     is only one operator defined, which takes a population and does stuff to
     it. It needn't be a complete algorithm, can be also a step of an
     algorithm. This class just gives a common interface to linear
     population-transforming algorithms.
+
+    @ingroup Algorithms
 */
 template< class EOT >
 class eoAlgo : public eoUF<eoPop<EOT>&, void>

eo/src/eoCellularEasyEA.h

@@ -33,8 +33,9 @@
 
 /**
    The abstract cellular easy algorithm. 
- */
 
+   @ingroup Algorithms
+ */
 template <class EOT> class eoCellularEasyEA : public eoAlgo <EOT> {
   
 public :

eo/src/eoEDA.h

@@ -30,12 +30,13 @@
 
 #include <eoDistribution.h>
 
-/** eoEDA: Estimation of Distribution Algorithm within EO
+/** The abstract class for estimation of disribution algorithms. 
- *  
+ * This design evolve a probability distribution 
- *  The abstract class for algorithms that evolve a probability distribution 
  *  on the spaces of populations rather than a population
  *
- * It IS NOT an eoAlgo, as it evolves a distribution, not a population
+ * It IS NOT an eoAlgo, as it evolves a distribution, not a population.
+ *
+ * @ingroup Algorithms
 */
 
 template<class EOT> class eoEDA: public eoUF<eoDistribution<EOT>&, void>

eo/src/eoEasyEA.h

@@ -29,7 +29,6 @@
 
 #include <apply.h>
 #include <eoAlgo.h>
-#include <eoPopAlgo.h>
 #include <eoPopEvalFunc.h>
 #include <eoContinue.h>
 #include <eoSelect.h>
@@ -59,6 +58,8 @@ Change (MS, July 3. 2001):
 
 Note: it looks ugly only because we wanted to authorize many different
   constructors. Please only look at the operator() and there shall be light
+
+  @ingroup Algorithms
 */
 template<class EOT> class eoEasyEA: public eoAlgo<EOT>
   {

eo/src/eoEasyPSO.h

@@ -32,14 +32,18 @@
 #include <eoFlight.h>
 //-----------------------------------------------------------------------------
 
-/** An easy-to-use particle swarm algorithm; you can use any particle,
+/** An easy-to-use particle swarm algorithm. 
-*   any flight, any topology... The main steps are :
+* Use any particle, any flight, any topology... 
+*
+*   The main steps are :
 * 	  (The population  is expected to be already evaluated)
 * 	 - for each generation and each particle pi
 * 	 - evaluate the velocities
 * 	 	-- perform the fligth of pi
 *    	-- evaluate pi
 *    	-- update the neighborhoods
+*
+* @ingroup Algorithms
 */
 template < class POT > class eoEasyPSO:public eoPSO < POT >
 {

eo/src/eoPSO.h

@@ -34,6 +34,8 @@
     is only one operator defined, which takes a population and does stuff to
     it. It needn't be a complete algorithm, can be also a step of an
     algorithm. Only used for mono-objective cases.
+
+    @ingroup Algorithms
 */
 template < class POT > class eoPSO:public eoAlgo < POT >{};
 

eo/src/eoPopAlgo.h

@@ -1,17 +0,0 @@
-// -*- mode: c++; c-indent-level: 4; c++-member-init-indent: 8; comment-column: 35; -*-
-
-#ifndef eoPopAlgo_h
-#define eoPopAlgo_h
-
-#include <eoPop.h>
-#include <eoFunctor.h>
-
-/**
-   For all "population transforming" algos ... 
- */
-
-template <class EOT> class eoPopAlgo : public eoUF <eoPop <EOT> &, void> {
-    
-} ;
-	
-#endif

eo/src/eoSGA.h

@@ -43,8 +43,9 @@
  * course an evaluation function (eoEvalFunc) and a continuator
  * (eoContinue) which gives the stopping criterion. Performs full
  * generational replacement.
+ *
+ * @ingroup Algorithms
  */
-
 template <class EOT>
 class eoSGA : public eoAlgo<EOT>
 {

eo/src/eoSimpleEDA.h

@@ -34,13 +34,15 @@
 #include <eoDistribUpdater.h>
 #include <eoEvalFunc.h>
 
-/** eoSimpleEDA: a very simple Estimation of Distribution Algorithm
+/** A very simple Estimation of Distribution Algorithm
  *  
  *  The algorithm that evolves a probability distribution 
  *  on the spaces of populations with the loop
  *                 generate a population from the current distribution
  *                 evaluate that population
  *                 update the distribution
+ *
+ *  @ingroup Algorithms
 */
 
 template<class EOT> class eoSimpleEDA: public eoEDA<EOT>

eo/src/eoSyncEasyPSO.h

@@ -34,13 +34,17 @@
 //-----------------------------------------------------------------------------
 
 /** An easy-to-use synchronous particle swarm algorithm; you can use any particle,
-*   any flight, any topology... The main steps are :
+*   any flight, any topology... 
+*
+*   The main steps are :
 * 	 - perform a first evaluation of the population
 * 	 - for each generation
 * 	 - evaluate ALL the velocities
 * 	 	-- perform the fligth of ALL the particles
 *    	-- evaluate ALL the particles
 *    	-- update the neighborhoods
+*
+*   @ingroup Algorithms
 */
 template < class POT > class eoSyncEasyPSO:public eoPSO < POT >
 {