grouping classes in documentation

eo/src/eoInt.h

@@ -33,6 +33,8 @@
 
 /** eoInt: implementation of simple integer-valued chromosome.
   * based on eoVector class
+  *
+  * @ingroup Representations
 */
 template <class FitT> class eoInt: public eoVector<FitT, int>
 {

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

eo/src/eoInvalidateOps.h

@@ -29,6 +29,8 @@
 
 #include <eoOp.h>
 
+/** @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

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 WeightType, class StopCriteriaType> class eoLinearDecreasingWeightUp:public eoWeightUpdater<WeightType>
 {

eo/src/eoLinearFitScaling.h

@@ -38,6 +38,8 @@
  *  truncate negative values to 0 -
  *
  * to be used within an eoSelectFromWorth object
+ *
+ * @ingroup Selectors
  */
 template <class EOT>
 class eoLinearFitScaling : public eoPerf2Worth<EOT> // false: do not cache fitness

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 >

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

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 Chrom> class eoMerge: public eoBF<const eoPop<Chrom>&, eoPop<Chrom>&, void>
@@ -51,6 +54,8 @@ template<class Chrom> class eoMerge: public eoBF<const eoPop<Chrom>&, eoPop<Chro
 /**
 Straightforward elitism class, specify the number of individuals to copy
 into new geneneration or the rate w.r.t. pop size
+ 
+@ingroup Replacors
 */
 template <class EOT> class eoElitism : public eoMerge<EOT>
 {
@@ -103,6 +108,7 @@ private :
 
 /**
 No elite
+@ingroup Replacors
 */
 template <class EOT> class eoNoElitism : public eoElitism<EOT>
 {
@@ -112,6 +118,7 @@ template <class EOT> class eoNoElitism : public eoElitism<EOT>
 
 /**
 Very elitist class, copies entire population into next gen
+@ingroup Replacors
 */
 template <class EOT> class eoPlus : public eoMerge<EOT>
 {

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 EOT>
 class eoMergeReduce : public eoReplacement<EOT>
@@ -68,6 +69,7 @@ class eoMergeReduce : public eoReplacement<EOT>
 
 /**
 ES type of replacement strategy: first add parents to population, then truncate
+@ingroup Replacors
 */
 template <class EOT>
 class eoPlusReplacement : public eoMergeReduce<EOT>
@@ -82,6 +84,7 @@ class eoPlusReplacement : public eoMergeReduce<EOT>
 
 /**
 ES type of replacement strategy: ignore parents, truncate offspring
+@ingroup Replacors
 */
 template <class EOT>
 class eoCommaReplacement : public eoMergeReduce<EOT>
@@ -97,6 +100,7 @@ class eoCommaReplacement : public eoMergeReduce<EOT>
 /**
 EP type of replacement strategy: first add parents to population, 
    then truncate using EP tournament
+@ingroup Replacors
 */
 template <class EOT>
 class eoEPReplacement : public eoMergeReduce<EOT>

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
 {

eo/src/eoOneToOneBreeder.h

@@ -38,15 +38,15 @@
 #include <eoPopulator.h>
 #include <utils/eoHowMany.h>
 
-/*****************************************************************************
- * 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 EOT>
 class eoOneToOneBreeder: public eoBreed<EOT>

eo/src/eoOp.h

@@ -29,6 +29,7 @@
 #include <eoPrintable.h>
 #include <eoFunctor.h>
 #include <utils/eoRNG.h>
+
 /**
 @defgroup Operators Evolutionary Operators
 

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 EOT>
 class eoOpContainer : public eoGenOp<EOT>
@@ -83,6 +85,8 @@ class eoOpContainer : public eoGenOp<EOT>
  *  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 EOT>
 class eoSequentialOp : public eoOpContainer<EOT>

eo/src/eoOpSelMason.h

@@ -20,21 +20,20 @@
 
     Contact: todos@geneura.ugr.es, http://geneura.ugr.es
  */
-//-----------------------------------------------------------------------------
 
 #ifndef _EOOPSELMASON_H
 #define _EOOPSELMASON_H
 
-//-----------------------------------------------------------------------------
-#include <eoProportionalOpSel.h>
 #include <eoOpFactory.h>	// for eoFactory and eoOpFactory
 
 #include <map>
 
-//-----------------------------------------------------------------------------
 
 /** 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 eoClass>
 class eoOpSelMason: public eoFactory<eoOpSelector<eoClass> > {
 	

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 Chrom> class eoOrderXover: public eoQuadOp<Chrom>
 {

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 EOT, class WorthT = double>
 class eoPerf2Worth : public eoUF<const eoPop<EOT>&, void>, public eoValueParam<std::vector<WorthT> >
@@ -106,6 +109,8 @@ public:
 
 /**
 Perf2Worth with fitness cache
+@ingroup Selectors
+@ingroup Utilities
 */
 template <class EOT, class WorthT = typename EOT::Fitness>
 class eoPerf2WorthCached : public eoPerf2Worth<EOT, WorthT>
@@ -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 EOT>
 class eoNoPerf2Worth : public eoPerf2Worth<EOT, typename EOT::Fitness>
 {

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 <eoContinue.h>
 #include <eoPop.h>
 
+/** A continue that becomes true periodically.
+ */
 template <class EOT> class eoPeriodicContinue: public eoContinue <EOT> {
 
 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 <EOT> & pop);
+  bool operator () (const eoPop <EOT> & pop)
+  {
+    return ((++ counter) % period) != 0 ;
+  }
+
     
 private:
 
@@ -45,19 +52,5 @@ private:
   unsigned counter;
 
 };
-
-template <class EOT> 
-eoPeriodicContinue <EOT> :: eoPeriodicContinue (unsigned __period, unsigned __init_counter
-						) : period (__period),
-						    counter (__init_counter) {
-
-}
-
-template <class EOT> 
-bool eoPeriodicContinue <EOT> :: operator () (const eoPop <EOT> & __pop) {
-    
-  return ((++ counter) % period) != 0 ;
-}
-
 #endif
 

eo/src/eoPersistent.cpp

@@ -7,7 +7,6 @@
 
 //Implementation of these objects
 
-//-----------------------------------------------------------------------------
 
 std::istream & operator >> ( std::istream& _is, eoPersistent& _o ) {
   _o.readFrom(_is);

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 EOT>
 class eoPop: public std::vector<EOT>, public eoObject, public eoPersistent
 {
@@ -333,9 +334,6 @@ public:
     for (unsigned i=0; i<size(); i++)
       this->operator[](i).invalidate();
   }
-
- protected:
-
 };
 
 #endif

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 EOT>
 class eoPopEvalFunc : public eoBF<eoPop<EOT> & , eoPop<EOT> &, void> 
@@ -55,6 +57,8 @@ class eoPopEvalFunc : public eoBF<eoPop<EOT> & , eoPop<EOT> &, void>
 
 /** eoPopLoopEval: an instance of eoPopEvalFunc that simply applies 
  *     a private eoEvalFunc to all offspring
+ *
+ *    @ingroup Evaluation
  */
 template<class EOT>
 class eoPopLoopEval : public eoPopEvalFunc<EOT> {
@@ -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 EOT>
 class eoTimeVaryingLoopEval : public eoPopEvalFunc<EOT> {