Adjust code to perform to C++ standard according to gcc-3.4

interpretation... (Have not compiled/checked/changed paradisEO.)

That is, the current code compiles with gcc-3.4 and the checks
(besides t-MGE1bit) all pass.

eo/app/gprop/mlp.h

@@ -464,4 +464,5 @@ namespace mlp {
 
 // Local Variables:
 // mode:C++
+// c-file-style: "Stroustrup"
 // End:

eo/contrib/MGE/eoVirus.h

@@ -18,7 +18,7 @@
 
     Contact: todos@geneura.ugr.es, http://geneura.ugr.es
              Marc.Schoenauer@polytechnique.fr
-CVS Info: $Date: 2003-02-27 19:26:44 $ $Header: /home/nojhan/dev/eodev/eodev_cvs/eo/contrib/MGE/eoVirus.h,v 1.2 2003-02-27 19:26:44 okoenig Exp $ $Author: okoenig $
+CVS Info: $Date: 2004-12-23 15:29:07 $ $Header: /home/nojhan/dev/eodev/eodev_cvs/eo/contrib/MGE/eoVirus.h,v 1.3 2004-12-23 15:29:07 kuepper Exp $ $Author: kuepper $
 */
 
 #ifndef eoVirus_h
@@ -43,9 +43,15 @@ CVS Info: $Date: 2003-02-27 19:26:44 $ $Header: /home/nojhan/dev/eodev/eodev_cvs
 \ingroup bitstring
   * based on STL's vector<bool> specialization.
 */
-template <class FitT> class eoVirus: public eoBit<FitT>
+template <class FitT>
+class eoVirus: public eoBit<FitT>
 {
- public:
+public:
+
+    using eoBit<FitT>::begin;
+    using eoBit<FitT>::end;
+    using eoBit<FitT>::size;
+
 
   /**
    * (Default) Constructor.
@@ -110,3 +116,9 @@ template <class FitT> class eoVirus: public eoBit<FitT>
 //-----------------------------------------------------------------------------
 
 #endif //eoBit_h
+
+
+// Local Variables:
+// mode: C++
+// c-file-style: "Stroustrup"
+// End:

eo/src/eoDominanceMap.h

@@ -46,15 +46,13 @@
 template <class EoType>
 class eoDominanceMap : public eoUF<const eoPop<EoType>&, void>, public std::vector<std::vector<bool> >
 {
-  public :
+public:
 
-  /**
+    /** Clears the map */
-    Clears the map
+    void clear() {
-  */
-  void clear()
-  {
         std::vector<std::vector<bool> >::clear();
-    fitnesses.clear();
+#warning Is this correct? Was: "fitnesses.clear()"
+        fitness.clear();
     }
 
   /**

eo/src/eoLinearFitScaling.h

@@ -43,19 +43,21 @@ template <class EOT>
 class eoLinearFitScaling : public eoPerf2Worth<EOT> // false: do not cache fitness
 {
 public:
+
+    using eoLinearFitScaling< EOT >::value;
+
     /* Ctor:
-   @param _p selective pressure (in (1,2]
+       @param _p selective pressure (in (1,2])
        @param _e exponent (1 == linear)
     */
-  eoLinearFitScaling(double _p=2.0):
+    eoLinearFitScaling(double _p=2.0)
-    pressure(_p) {}
+        : pressure(_p) {}
 
     /* COmputes the ranked fitness: fitnesses range in [m,M]
        with m=2-pressure/popSize and M=pressure/popSize.
        in between, the progression depends on exponent (linear if 1).
     */
-  virtual void operator()(const eoPop<EOT>& _pop)
+    virtual void operator()(const eoPop<EOT>& _pop) {
-    {
         unsigned pSize =_pop.size();
         // value() refers to the vector of worthes (we're in an eoParamvalue)
         value().resize(pSize);
@@ -76,13 +78,12 @@ public:
         double alpha = (pressure-1)/denom;
         double beta = (bestFitness - pressure*averageFitness)/denom;
 
-    for (i=0; i<pSize; i++) // truncate to 0
+        for (i=0; i<pSize; i++) { // truncate to 0
-      {
             value()[i] = std::max(alpha*_pop[i].fitness()+beta, 0.0);
         }
-
     }
- private:
+
+private:
     double pressure;	// selective pressure
 };
 

eo/src/eoNDSorting.h

@@ -41,9 +41,12 @@
 template <class EOT>
 class eoNDSorting : public eoPerf2WorthCached<EOT, double>
 {
-  public :
+public:
 
-      eoNDSorting() : nasty_declone_flag_that_only_is_implemented_for_two_objectives(false)
+    using eoNDSorting< EOT >::value;
+
+    eoNDSorting()
+        : nasty_declone_flag_that_only_is_implemented_for_two_objectives(false)
         {}
 
     /** Pure virtual function that calculates the 'distance' for each element in the current front
@@ -409,19 +412,24 @@ public :
   double nicheSize;
 };
 
-/**
+/** @brief Fast Elitist Non-Dominant Sorting Genetic Algorithm
-  Adapted from Deb, Agrawal, Pratab and Meyarivan: A Fast Elitist Non-Dominant Sorting Genetic Algorithm for MultiObjective Optimization: NSGA-II
-  KanGAL Report No. 200001
 
-  Note that this class does not do the sorting per se, but the sorting of it worth_std::vector will give the right order
+  Adapted from Deb, Agrawal, Pratab and Meyarivan: A Fast Elitist
+  Non-Dominant Sorting Genetic Algorithm for MultiObjective
+  Optimization: NSGA-II KanGAL Report No. 200001
 
-  The crowding distance is calculated as the sum of the distances to the nearest neighbours. As we need to return the
+  Note that this class does not do the sorting per se, but the sorting
-  penalty value, we have to invert that and invert it again in the base class, but such is life, sigh
+  of it worth_std::vector will give the right order
+
+  The crowding distance is calculated as the sum of the distances to
+  the nearest neighbours. As we need to return the penalty value, we
+  have to invert that and invert it again in the base class, but such
+  is life, sigh
 */
 template <class EOT>
 class eoNDSorting_II : public eoNDSorting<EOT>
 {
-  public:
+public:
 
     typedef std::pair<double, unsigned> double_index_pair;
 

eo/src/eoOpContainer.h

@@ -87,22 +87,20 @@ class eoOpContainer : public eoGenOp<EOT>
 template <class EOT>
 class eoSequentialOp : public eoOpContainer<EOT>
 {
-  public :
+public:
+
+    using eoOpContainer< EOT >::ops;
+    using eoOpContainer< EOT >::rates;
+
     typedef unsigned position_type;
 
 
-  void apply(eoPopulator<EOT>& _pop)
+    void apply(eoPopulator<EOT>& _pop) {
-  {
         position_type pos = _pop.tellp();
-
+        for (size_t i = 0; i < rates.size(); ++i) {
-     for (size_t i = 0; i < rates.size(); ++i)
-     {
             _pop.seekp(pos);
-
+            do {
-        do
+                if (eo::rng.flip(rates[i])) {
-        {
-          if (eo::rng.flip(rates[i]))
-          {
                     //            try
                     //            {
                     // apply it to all the guys in the todo std::list
@@ -124,18 +122,22 @@ class eoSequentialOp : public eoOpContainer<EOT>
     }
     virtual std::string className() const {return "SequentialOp";}
 
-  private :
+private:
 
     std::vector<size_t> to_apply;
     std::vector<size_t> production;
 };
 
 
+
 /** The proportional versions: easy! */
 template <class EOT>
 class eoProportionalOp : public eoOpContainer<EOT>
 {
-    public :
+public:
+
+    using eoOpContainer< EOT >::ops;
+    using eoOpContainer< EOT >::rates;
 
     void apply(eoPopulator<EOT>& _pop)
     {

eo/src/eoParetoRanking.h

@@ -39,10 +39,13 @@
 template <class EOT>
 class eoParetoRanking : public eoPerf2WorthCached<EOT, double>
 {
-  public :
+public:
 
-    eoParetoRanking(eoDominanceMap<EOT>& _dominanceMap) :
+    using eoParetoRanking< EOT>::value;
-      eoPerf2WorthCached<EOT, double>(), dominanceMap(_dominanceMap) {}
+
+    eoParetoRanking(eoDominanceMap<EOT>& _dominanceMap)
+        : eoPerf2WorthCached<EOT, double>(), dominanceMap(_dominanceMap)
+        {}
 
     void calculate_worths(const eoPop<EOT>& _pop)
     {

eo/src/eoPerf2Worth.h

@@ -35,20 +35,24 @@
 #include <vector>
 #include <string>
 
-/** Base class to transform raw fitnesses into fitness for selection
+/** @brief Base class to transform raw fitnesses into fitness for selection
 
 @see eoSelectFromWorth
 */
 template <class EOT, class WorthT = double>
 class eoPerf2Worth : public eoUF<const eoPop<EOT>&, void>, public eoValueParam<std::vector<WorthT> >
 {
-  public:
+public:
-  eoPerf2Worth(std::string _description = "Worths"):eoValueParam<std::vector<WorthT> >(std::vector<WorthT>(0),
-					      _description) {}
 
-                  /**
+    using eoPerf2Worth<EOT, WorthT>::value;
-  Sort population according to worth, will keep the worths and fitness_cache in sync with the population.
+
-  */
+    /** @brief default constructor */
+    eoPerf2Worth(std::string _description = "Worths")
+        : eoValueParam<std::vector<WorthT> >(std::vector<WorthT>(0), _description)
+        {}
+
+    /** Sort population according to worth, will keep the worths and
+        fitness_cache in sync with the population. */
   virtual void sort_pop(eoPop<EOT>& _pop)
   { // start with a std::vector of indices
       std::vector<unsigned> indices(_pop.size());
@@ -75,28 +79,28 @@ class eoPerf2Worth : public eoUF<const eoPop<EOT>&, void>, public eoValueParam<s
     std::swap(value(), tmp_worths);
   }
 
-  /** helper class used to sort indices into populations/worths
+    /** helper class used to sort indices into populations/worths */
-  */
     class compare_worth
     {
-  public :
+    public:
+
         compare_worth(const std::vector<WorthT>& _worths) : worths(_worths) {}
 
-    bool operator()(unsigned a, unsigned b) const
+        bool operator()(unsigned a, unsigned b) const {
-    {
             return worths[b] < worths[a]; // sort in descending (!) order
         }
 
-  private :
+    private:
 
         const std::vector<WorthT>& worths;
     };
 
-  virtual void resize(eoPop<EOT>& _pop, unsigned sz)
+
-  {
+
+    virtual void resize(eoPop<EOT>& _pop, unsigned sz) {
         _pop.resize(sz);
         value().resize(sz);
-  }
+    };
 
 };
 
@@ -106,7 +110,10 @@ Perf2Worth with fitness cache
 template <class EOT, class WorthT = typename EOT::Fitness>
 class eoPerf2WorthCached : public eoPerf2Worth<EOT, WorthT>
 {
-  public:
+public:
+
+    using eoPerf2Worth<EOT, WorthT>::value;
+
     eoPerf2WorthCached(std::string _description = "Worths") : eoPerf2Worth<EOT, WorthT>(_description) {}
 
 
@@ -164,7 +171,7 @@ class eoPerf2WorthCached : public eoPerf2Worth<EOT, WorthT>
       indices[i] = i;
     }
 
-    std::sort(indices.begin(), indices.end(), eoPerf2Worth<EOT,WorthT>::compare_worth(value()));
+    std::sort(indices.begin(), indices.end(), compare_worth(value()));
 
     eoPop<EOT>      tmp_pop;
     tmp_pop.resize(_pop.size());
@@ -216,22 +223,25 @@ class eoPerf2WorthCached : public eoPerf2Worth<EOT, WorthT>
   std::vector <typename EOT::Fitness> fitness_cache;
 };
 
-/**
+
-  A dummy perf2worth, just in case you need it
+
-*/
+/** A dummy perf2worth, just in case you need it */
 template <class EOT>
 class eoNoPerf2Worth : public eoPerf2Worth<EOT, typename EOT::Fitness>
 {
-  public:
+public:
+
+    using eoValueParam< EOT >::value;
 
     // default behaviour, just copy fitnesses
-    void operator()(const eoPop<EOT>& _pop)
+    void operator()(const eoPop<EOT>& _pop) {
-    {
         unsigned i;
-      value.resize(_pop.size());
+        value().resize(_pop.size());
         for (i = 0; i < _pop.size(); ++i)
             value()[i]=_pop[i];
     }
 };
 
+
+
 #endif

eo/src/eoPopulator.h

@@ -120,15 +120,15 @@ public :
    */
   virtual const EOT& select() = 0;
 
-protected :
+protected:
     eoPop<EOT>& dest;
     typename eoPop<EOT>::iterator current;
     const eoPop<EOT>& src;
 
-private :
+private:
-  void get_next()
+
-  {
+  void get_next() {
-    if (current == dest.end())
+    if(current == dest.end())
       { // get new individual from derived class select()
         dest.push_back(select());
         current = dest.end();
@@ -143,30 +143,33 @@ private :
 };
 
 
-/** SeqPopulator: an eoPopulator that sequentially goes through the population
+/** SeqPopulator: an eoPopulator that sequentially goes through the
-is supposed to be used after a batch select of a whole bunch or genitors
+    population is supposed to be used after a batch select of a whole
- */
+    bunch or genitors
+*/
 template <class EOT>
 class eoSeqPopulator : public eoPopulator<EOT>
 {
-public :
+public:
 
     eoSeqPopulator(const eoPop<EOT>& _pop, eoPop<EOT>& _dest) :
         eoPopulator<EOT>(_pop, _dest), current(0) {}
 
     /** the select method simply returns next individual in the src pop */
-  const EOT& select(void)
+    const EOT& select(void) {
-  {
+        if(current >= eoPopulator< EOT >::src.size()) {
-    if (current >= src.size())
-      {
             throw OutOfIndividuals();
         }
 
-    const EOT& res = src[current++];
+        const EOT& res = eoPopulator< EOT >::src[current++];
         return res;
     }
 
-private :
+
+private:
+
+    struct OutOfIndividuals {};
+
     unsigned current;
 };
 
@@ -178,19 +181,21 @@ template <class EOT>
 class eoSelectivePopulator : public eoPopulator<EOT>
 {
 public :
+
+    using eoPopulator< EOT >::src;
+
     eoSelectivePopulator(const eoPop<EOT>& _pop, eoPop<EOT>& _dest, eoSelectOne<EOT>& _sel)
         : eoPopulator<EOT>(_pop, _dest), sel(_sel)
-    {
+        { sel.setup(_pop); };
-      sel.setup(_pop);
-    }
 
     /** the select method actually selects one guy from the src pop */
-  const EOT& select()
+    const EOT& select() {
-  {
         return sel(src);
     }
 
-private :
+
+private:
+
     eoSelectOne<EOT>& sel;
 };
 

eo/src/eoRanking.h

@@ -38,6 +38,9 @@ template <class EOT>
 class eoRanking : public eoPerf2Worth<EOT> // false: do not cache fitness
 {
 public:
+
+    using eoRanking< EOT >::value;
+
   /* Ctor:
    @param _p selective pressure (in (1,2]
    @param _e exponent (1 == linear)

eo/src/eoScalarFitnessAssembled.h

@@ -88,6 +88,12 @@ template <class ScalarType, class Compare, class FitnessTraits >
 class eoScalarFitnessAssembled : public std::vector<ScalarType> {
 
 public:
+
+    using std::vector< ScalarType >::empty;
+    using std::vector< ScalarType >::front;
+    using std::vector< ScalarType >::size;
+
+
   typedef typename std::vector<ScalarType> baseVector;
   typedef typename baseVector::size_type size_type;
 
@@ -130,11 +136,10 @@ public:
 
   eoScalarFitnessAssembled& operator=( const ScalarType& v ) {
 
-    if ( empty() )
+      if( empty() )
           push_back( v );
       else
           front() = v;
-  
       return *this;
   }
 

eo/src/eoSelectFromWorth.h

@@ -51,40 +51,36 @@ template <class EOT, class WorthType = double>
 class eoSelectFromWorth : public eoSelectOne<EOT>
 {
 public:
-  /* Default ctor from an eoPerf2Worth object
+
-   */
+    /* Default ctor from an eoPerf2Worth object */
-  eoSelectFromWorth(eoPerf2Worth<EOT, WorthType> & _perf2Worth) :
+    eoSelectFromWorth(eoPerf2Worth<EOT, WorthType>& _perf2Worth)
-    perf2Worth(_perf2Worth) {}
+        : perf2Worth(_perf2Worth)
+        {}
 
     /* setup the worthes */
-  virtual void setup(const eoPop<EOT>& _pop)
+    virtual void setup(const eoPop<EOT>& pop) {
-  {
+        perf2Worth(pop);
-    perf2Worth(_pop);
-
 #ifndef NDEBUG
-  fitness.resize(_pop.size());
+        fitness.resize(pop.size());
-  for (unsigned i = 0; i < _pop.size(); ++i)
+        for (unsigned i = 0; i < pop.size(); ++i) {
-  {
+            fitness[i] = pop[i].fitness();
-    fitness[i] = _pop[i].fitness();
         }
 #endif
     }
 
+
 protected:
-  eoPerf2Worth<EOT, WorthType> & perf2Worth;
+
+    eoPerf2Worth<EOT, WorthType>& perf2Worth;
 
 #ifndef NDEBUG
     std::vector<typename EOT::Fitness> fitness;
-  void check_sync(unsigned index, const EOT& _eo)
+    void check_sync(unsigned index, const EOT& _eo) {
-  {
+        if (fitness[index] != _eo.fitness()) {
-    if (fitness[index] != _eo.fitness())
-    {
             throw std::runtime_error("eoSelectFromWorth: fitnesses are not in sync");
         }
     }
-
 #endif
-
 };
 
 
@@ -95,35 +91,33 @@ template <class EOT, class WorthT = double>
 class eoDetTournamentWorthSelect : public eoSelectFromWorth<EOT, WorthT>
 {
 public:
+
+    using eoSelectFromWorth<EOT, WorthT>::perf2Worth;
+
     typedef typename std::vector<WorthT>::iterator worthIterator;
 
-  /* Default ctor from an eoPerf2Worth object +  tournament size
+    /* Default ctor from an eoPerf2Worth object +  tournament size */
-   */
+    eoDetTournamentWorthSelect(eoPerf2Worth<EOT, WorthT>& perf2Worth,
-  eoDetTournamentWorthSelect(eoPerf2Worth<EOT, WorthT> &_perf2Worth,
+                               unsigned _tSize)
-			     unsigned _tSize) :
+        : eoSelectFromWorth<EOT, WorthT>(perf2Worth), tSize(_tSize) {}
-    eoSelectFromWorth<EOT, WorthT>(_perf2Worth), tSize(_tSize) {}
-
-  /* Perform deterministic tournament on worthes
-     by calling the appropriate fn
-     see selectors.h
-  */
-  virtual const EOT& operator()(const eoPop<EOT>& _pop)
-  {
-    worthIterator it = deterministic_tournament(
-			perf2Worth.value().begin(),
-			perf2Worth.value().end(), tSize);
 
+    /* Perform deterministic tournament on worthes by calling the
+       appropriate fn see selectors.h */
+    virtual const EOT& operator()(const eoPop<EOT>& pop) {
+        worthIterator it = deterministic_tournament(perf2Worth.value().begin(),
+                                                    perf2Worth.value().end(),
+                                                    tSize);
         unsigned index = it - perf2Worth.value().begin();
-
 #ifndef NDEBUG
         // check whether the stuff is still in sync
-  check_sync(index, _pop[index]);
+        check_sync(index, pop[index]);
 #endif
-
+        return pop[index];
-    return _pop[index];
     }
 
+
 private:
+
     unsigned tSize;
 };
 
@@ -134,22 +128,23 @@ template <class EOT, class WorthT = double>
 class eoStochTournamentWorthSelect : public eoSelectFromWorth<EOT, WorthT>
 {
 public:
+
+    using eoSelectFromWorth<EOT, WorthT>::perf2Worth;
+
     typedef typename std::vector<WorthT>::iterator worthIterator;
 
-  /* Default ctor from an eoPerf2Worth object +  tournament rate
+    /* Default ctor from an eoPerf2Worth object +  tournament rate */
-   */
+    eoStochTournamentWorthSelect(eoPerf2Worth<EOT, WorthT> &_perf2Worth, double _tRate)
-  eoStochTournamentWorthSelect(eoPerf2Worth<EOT, WorthT> &_perf2Worth,
+        : eoSelectFromWorth<EOT, WorthT>(_perf2Worth), tRate(_tRate)
-			     double _tRate) :
+        {}
-    eoSelectFromWorth<EOT, WorthT>(_perf2Worth), tRate(_tRate) {}
 
   /* Perform stochastic tournament on worthes
      by calling the appropriate fn in selectors.h
   */
-  virtual const EOT& operator()(const eoPop<EOT>& _pop)
+  virtual const EOT& operator()(const eoPop<EOT>& _pop) {
-  {
+      worthIterator it = stochastic_tournament(perf2Worth.value().begin(),
-    worthIterator it = stochastic_tournament(
+                                               perf2Worth.value().end(),
-			perf2Worth.value().begin(),
+                                               tRate);
-			perf2Worth.value().end(), tRate);
 
     unsigned index = it - perf2Worth.value().begin();
 
@@ -172,12 +167,16 @@ template <class EOT, class WorthT = double>
 class eoRouletteWorthSelect : public eoSelectFromWorth<EOT, WorthT>
 {
 public:
+
+    using eoSelectFromWorth<EOT, WorthT>::perf2Worth;
+
     typedef typename std::vector<WorthT>::iterator worthIterator;
 
-  /* Default ctor from an eoPerf2Worth object
+
-   */
+    /* Default ctor from an eoPerf2Worth object */
-  eoRouletteWorthSelect(eoPerf2Worth<EOT, WorthT> &_perf2Worth) :
+    eoRouletteWorthSelect(eoPerf2Worth<EOT, WorthT> &_perf2Worth)
-    eoSelectFromWorth<EOT, WorthT>(_perf2Worth) {}
+        : eoSelectFromWorth<EOT, WorthT>(_perf2Worth)
+        {}
 
   /* We have to override the default behavior to compute the total
    * only once!
@@ -195,16 +194,14 @@ public:
      by calling the appropriate fn
      see selectors.h
   */
-  virtual const EOT& operator()(const eoPop<EOT>& _pop)
+  virtual const EOT& operator()(const eoPop<EOT>& _pop) {
-  {
+ //     cout << "On affiche les worths\n";
-//     cout << "On affiche les worths\n";
+ //     for (unsigned i=0;
-//     for (unsigned i=0; 
+ // 	 i<perf2Worth.value().size();
-// 	 i<perf2Worth.value().size(); 
+ // 	 i++)
-// 	 i++)
+ //       cout << perf2Worth.value().operator[](i) << "\n";
-//       cout << perf2Worth.value().operator[](i) << "\n";
+ //     cout << endl;
-//     cout << endl;
+      worthIterator it = roulette_wheel(perf2Worth.value().begin(),
-    worthIterator it = roulette_wheel(
-			perf2Worth.value().begin(),
                                         perf2Worth.value().end(),
                                         total);
 
@@ -216,7 +213,7 @@ public:
 #endif
 
     return _pop[index];
-    return _pop[it-perf2Worth.value().begin()];
+    return _pop[it - perf2Worth.value().begin()];
   }
 
 private:

eo/src/eoSharing.h

@@ -78,7 +78,11 @@
 template <class EOT>
 class eoSharing : public eoPerf2Worth<EOT>
 {
-  public:
+public:
+
+    using eoSharing< EOT >::value;
+
+
   /* Ctor requires a distance - cannot have a default distance! */
   eoSharing(double _nicheSize, eoDistance<EOT> & _dist) : eoPerf2Worth<EOT>("Sharing"),
 					     nicheSize(_nicheSize),

eo/src/eoSurviveAndDie.h

@@ -64,22 +64,25 @@ protected:
 
 };
 
-/**
+/** An instance (theonly one as of today, Dec. 20, 2000) of an
-an instance (theonly one as of today, Dec. 20, 2000) of an eoSurviveAndDie, 
+    eoSurviveAndDie, that does everything deterministically
-that does everything deterministically
 
-used in eoDeterministicSaDReplacement
+    Used in eoDeterministicSaDReplacement.
 */
-
 template <class EOT>
 class eoDeterministicSurviveAndDie : public eoSurviveAndDie<EOT>
 {
 public:
-    eoDeterministicSurviveAndDie(double _survive, double _die, 
+
-				 bool _interpret_as_rate = true):
+    using eoSurviveAndDie< EOT >::howmanyDie;
-	eoSurviveAndDie<EOT>(_survive, _die, _interpret_as_rate)
+    using eoSurviveAndDie< EOT >::howmanySurvive;
+
+    /** constructor */
+    eoDeterministicSurviveAndDie(double _survive, double _die, bool _interpret_as_rate = true)
+        : eoSurviveAndDie< EOT >(_survive, _die, _interpret_as_rate)
     {}
 
+
     void operator()(eoPop<EOT> & _pop, eoPop<EOT> & _luckyGuys)
     {
 	unsigned pSize = _pop.size();

eo/src/eoVector.h

@@ -22,7 +22,7 @@
              Marc.Schoenauer@polytechnique.fr
 	     mak@dhi.dk
 
-    CVS Info: $Date: 2003-03-18 16:57:17 $ $Header: /home/nojhan/dev/eodev/eodev_cvs/eo/src/eoVector.h,v 1.15 2003-03-18 16:57:17 maartenkeijzer Exp $ $Author: maartenkeijzer $ 
+    CVS Info: $Date: 2004-12-23 15:29:06 $ $Header: /home/nojhan/dev/eodev/eodev_cvs/eo/src/eoVector.h,v 1.16 2004-12-23 15:29:06 kuepper Exp $ $Author: kuepper $
 
  */
 //-----------------------------------------------------------------------------
@@ -45,13 +45,25 @@
 template <class FitT, class GeneType>
 class eoVector : public EO<FitT>, public std::vector<GeneType>
 {
-    public :
+public:
+
+    using EO<FitT>::invalidate;
+    using std::vector<GeneType>::operator[];
+    using std::vector<GeneType>::begin;
+    using std::vector<GeneType>::end;
+    using std::vector<GeneType>::resize;
+    using std::vector<GeneType>::size;
 
     typedef GeneType                AtomType;
     typedef std::vector<GeneType>   ContainerType;
 
+    /** default constructor
 
-    eoVector(unsigned size = 0, GeneType value = GeneType()) : EO<FitT>(), std::vector<GeneType>(size, value)
+    @param size Length of vector (default is 0)
+    @param value Initial value of all elements (default is default value of type GeneType)
+    */
+    eoVector(unsigned size = 0, GeneType value = GeneType())
+        : EO<FitT>(), std::vector<GeneType>(size, value)
         {}
 
     /// copy ctor abstracting from the FitT

eo/src/es/eoEsFull.h

@@ -39,7 +39,11 @@ rates and correlated mutations.
 template <class Fit>
 class eoEsFull : public eoVector<Fit, double>
 {
-    public :
+public:
+
+    using eoEsFull< Fit >::size;
+
+
     typedef double Type;
 
     eoEsFull(void) : eoVector<Fit, double>() {}

eo/src/es/eoEsStdev.h

@@ -39,7 +39,9 @@ deviations.
 template <class Fit>
 class eoEsStdev : public eoVector<Fit, double>
 {
-    public :
+public:
+
+    using eoEsStdev< Fit >::size;
 
     typedef double Type;
 

eo/src/es/eoNormalMutation.h

@@ -113,9 +113,10 @@ private:
  *     but this sometimes takes a long time!!!
  */
 
-template<class EOT> class eoNormalMutation: public eoMonOp<EOT>
+template<class EOT> class eoNormalMutation
+    : public eoMonOp<EOT>
 {
- public:
+public:
   /**
    * (Default) Constructor.
    * The bounds are initialized with the global object that says: no bounds.
@@ -177,6 +178,9 @@ template<class EOT> class eoOneFifthMutation :
   public eoNormalMutation<EOT>, public eoUpdatable
 {
 public:
+
+    using eoNormalMutation< EOT >::Sigma;
+
     typedef typename EOT::Fitness Fitness;
 
   /**

eo/src/ga/eoBit.h

@@ -54,7 +54,11 @@
 */
 template <class FitT> class eoBit: public eoVector<FitT, bool>
 {
- public:
+public:
+
+    using eoVector< FitT, bool >::begin;
+    using eoVector< FitT, bool >::end;
+    using eoVector< FitT, bool >::size;
 
   /**
    * (Default) Constructor.
@@ -104,3 +108,9 @@ template <class FitT> class eoBit: public eoVector<FitT, bool>
 //-----------------------------------------------------------------------------
 
 #endif //eoBit_h
+
+
+// Local Variables:
+// mode: C++
+// c-file-style: "Stroustrup"
+// End:

eo/src/ga/eoPBILAdditive.h

@@ -104,8 +104,8 @@ public:
 		p[g] +=  lrw;
 	    }
 	// stay in [0,1] (possibly strictly due to tolerance)
-	p[g] = min(maxBound, p[g]);
+	p[g] = std::min(maxBound, p[g]);
-	p[g] = max(minBound, p[g]);
+	p[g] = std::max(minBound, p[g]);
       }
   }
 

eo/src/gp/eoParseTree.h

@@ -57,7 +57,13 @@ using namespace gp_parse_tree;
 template <class FType, class Node>
 class eoParseTree : public EO<FType>, public parse_tree<Node>
 {
-public :
+public:
+
+    using eoParseTree<FType, Node >::back;
+    using eoParseTree<FType, Node >::ebegin;
+    using eoParseTree<FType, Node >::eend;
+    using eoParseTree<FType, Node >::size;
+
 
     typedef typename parse_tree<Node>::subtree Subtree;
 
@@ -65,13 +71,11 @@ public :
     typedef Node reference;
     typedef const reference const_reference;
 
-    
-
-	
     /**
      * Default Constructor
      */
     eoParseTree(void)  {}
+
     /**
      * Copy Constructor
      * @param tree The tree to copy

eo/src/gp/parse_tree.h

@@ -719,7 +719,10 @@ private :
 
     class iterator : public base_iterator
     {
-    public :
+    public:
+
+        using base_iterator::node;
+
         typedef std::forward_iterator_tag iterator_category;
         typedef subtree value_type;
         typedef size_t distance_type;
@@ -736,9 +739,14 @@ private :
         subtree* operator->(void) { return node; }
     };
 
+
+
     class embedded_iterator : public base_iterator
     {
-    public :
+    public:
+
+        using base_iterator::node;
+
         typedef std::forward_iterator_tag iterator_category;
         typedef T value_type;
         typedef size_t distance_type;
@@ -757,7 +765,8 @@ private :
 
     class base_const_iterator
     {
-    public :
+    public:
+
         base_const_iterator() {}
         base_const_iterator(const subtree* n)  { node = n; }
 
@@ -808,7 +817,10 @@ private :
 
     class const_iterator : public base_const_iterator
     {
-    public :
+    public:
+
+        using base_iterator::node;
+
         typedef std::forward_iterator_tag iterator_category;
         typedef const subtree value_type;
         typedef size_t distance_type;
@@ -827,7 +839,10 @@ private :
 
     class embedded_const_iterator : public base_const_iterator
     {
-    public :
+    public:
+
+        using base_const_iterator::node;
+
 		typedef std::forward_iterator_tag iterator_category;
 		typedef const T value_type;
 		typedef size_t distance_type;

eo/src/other/eoExternalEO.h

@@ -40,13 +40,18 @@ class eoExternalEO : public EO<Fit>, virtual public External
 {
 public :
 
-  eoExternalEO(void) : EO<Fit>(), External() {}
+    eoExternalEO(void)
+        : EO<Fit>(), External()
+        {}
 
-  /**
+    /** Init externalEo with the struct itself and set fitness to zero */
-    Init externalEo with the struct itself and set fitness to zero
+    eoExternalEO(const External& ext)
-  */
+        : EO<Fit>(), External(ext)
-  eoExternalEO(const External& ext) : EO<Fit>(), External(ext) {}
+        {}
-  eoExternalEO(std::istream& is) : EO<Fit>(), External(ext) { readFrom(is); }
+
+    eoExternalEO(std::istream& is, const External& ext)
+        : EO<Fit>(), External(ext)
+        { readFrom(is); }
 
   /**
    * Read object, the external struct needs to have an operator>> defined

eo/src/other/eoString.h

@@ -26,6 +26,7 @@
 #define _eoString_H
 
 // STL libraries
+#include <iostream>
 #include <string>
 #include <stdexcept>
 
@@ -46,6 +47,7 @@ public:
     typedef char AtomType;
     typedef std::string   ContainerType;
 
+
   /// Canonical part of the objects: several ctors, copy ctor, dtor and assignment operator
   //@{
   /// ctor
@@ -58,7 +60,7 @@ public:
     EO<fitnessT>::printOn(os);
     os << ' ';
 
-    os << size() << ' ' << substr() << endl;
+    os << size() << ' ' << substr() << std::endl;
 
   }
 

eo/src/utils/eoAssembledFitnessStat.h

@@ -47,14 +47,18 @@ class eoAssembledFitnessAverageStat : public eoStat<EOT, double>
 {
 public :
 
+    using eoAssembledFitnessAverageStat< EOT >::value;
+
     typedef typename EOT::Fitness Fitness;
 
+
     eoAssembledFitnessAverageStat(unsigned _whichTerm=0, std::string _description = "Average Fitness")
-    : eoStat<EOT, double>(Fitness(), _description), whichFitnessTerm(_whichTerm) {}
+        : eoStat<EOT, double>(Fitness(), _description), whichFitnessTerm(_whichTerm)
+        {}
 
-  virtual void operator()(const eoPop<EOT>& _pop){
 
-    if ( whichFitnessTerm >= _pop[0].fitness().size() )
+    virtual void operator()(const eoPop<EOT>& _pop) {
+        if( whichFitnessTerm >= _pop[0].fitness().size() )
             throw std::logic_error("Fitness term requested out of range");
 
     double result =0.0;
@@ -82,21 +86,25 @@ private:
 template <class EOT>
 class eoAssembledFitnessBestStat : public eoStat<EOT, double>
 {
-public :
+public:
+
+    using eoAssembledFitnessBestStat< EOT >::value;
+
     typedef typename EOT::Fitness Fitness;
 
     eoAssembledFitnessBestStat(unsigned _whichTerm=0, std::string _description = "Best Fitness")
-    : eoStat<EOT, double>(Fitness(), _description), whichFitnessTerm(_whichTerm) {}
+        : eoStat<EOT, double>(Fitness(), _description), whichFitnessTerm(_whichTerm)
+        {}
 
-  virtual void operator()(const eoPop<EOT>& _pop){
+    virtual void operator()(const eoPop<EOT>& _pop) {
-    
+        if( whichFitnessTerm >= _pop[0].fitness().size() )
-    if ( whichFitnessTerm >= _pop[0].fitness().size() )
             throw std::logic_error("Fitness term requested out of range");
 
         value() = _pop.best_element().fitness()[whichFitnessTerm];
     }
 
 private:
+
     // Store an index of the fitness term to be evaluated in eoScalarFitnessAssembled
     unsigned whichFitnessTerm;
 };

eo/src/utils/eoFDCStat.h

@@ -38,9 +38,11 @@ so they can be snapshot by some eoGnuplotSnapshot ...
 template <class EOT>
 class eoFDCStat : public eoStat<EOT, double>
 {
-public :
+public:
-  /** Ctor without the optimum
+
-   */
+    using eoFDCStat < EOT>::value;
+
+    /** Ctor without the optimum */
   eoFDCStat(eoDistance<EOT> & _dist, std::string _description = "FDC") :
       eoStat<EOT,double>(0, _description), dist(_dist), boolOpt(false) {}
 

eo/src/utils/eoMOFitnessStat.h

@@ -36,6 +36,9 @@ template <class EOT, class FitT = typename EOT::Fitness>
 class eoFitnessStat : public eoSortedStat<EOT, std::vector<FitT> >
 {
 public :
+
+    using eoFitnessStat< EOT, FitT >::value;
+
     eoFitnessStat(std::string _description = "AllFitnesses") :
       eoSortedStat<EOT,std::vector<FitT> >(std::vector<FitT>(0), _description) {}
 
@@ -62,7 +65,10 @@ class eoMOFitnessStat : public eoSortedStat<EOT, std::vector<PartFitT> >
 #endif
 
 {
-public :
+public:
+
+    using eoMOFitnessStat< EOT, PartFitT >::value;
+
   /** Ctor: say what component you want
    */
   eoMOFitnessStat(unsigned _objective, std::string _description = "MO-Fitness") :

eo/src/utils/eoPopStat.h

@@ -54,7 +54,10 @@ inside an eoFileMonitor, as the eoState construct will work much better there.
 template <class EOT>
 class eoPopStat : public eoStat<EOT, std::string>
 {
-public :
+public:
+
+    using eoPopStat< EOT>::value;
+
   /** default Ctor, void std::string by default, as it appears
       on the description line once at beginning of evolution. and
       is meaningless there. _howMany defaults to 0, that is, the whole
@@ -115,18 +118,23 @@ inside an eoFileMonitor, as the eoState construct will work much better there.
 template <class EOT>
 class eoSortedPopStat : public eoSortedStat<EOT, std::string>
 {
-public :
+public:
-  /** default Ctor, void std::string by default, as it appears 
-   *  on the description line once at beginning of evolution. and
-   *  is meaningless there _howMany defaults to 0, that is, the whole
-   *  population
-   */
-  eoSortedPopStat(unsigned _howMany = 0, std::string _desc ="") : 
-    eoSortedStat<EOT, std::string>("", _desc) , combien( _howMany) {}
 
-  /** Fills the value() of the eoParam with the dump of the population.
+    using eoSortedPopStat< EOT>::value;
-      Adds a \n before so it does not get mixed up with the rest of the stats
+
-      that are written by the monitor it is probably used from.
+    /** default Ctor, void std::string by default, as it appears on
+        the description line once at beginning of evolution. and is
+        meaningless there _howMany defaults to 0, that is, the whole
+        population
+    */
+    eoSortedPopStat(unsigned _howMany = 0, std::string _desc ="")
+        : eoSortedStat<EOT, std::string>("", _desc) , combien( _howMany)
+        {}
+
+    /** Fills the value() of the eoParam with the dump of the
+        population. Adds a \n before so it does not get mixed up with
+        the rest of the stats that are written by the monitor it is
+        probably used from.
     */
 #ifdef HAVE_SSTREAM
     void operator()(const std::vector<const EOT*>& _pop)

eo/src/utils/eoScalarFitnessStat.h

@@ -36,7 +36,10 @@
 template <class EOT, class FitT = typename EOT::Fitness>
 class eoScalarFitnessStat : public eoSortedStat<EOT, std::vector<double> >
 {
-public :
+public:
+
+    using eoScalarFitnessStat< EOT, FitT >::value;
+
     eoScalarFitnessStat(std::string _description = "FitnessES",
 		      eoRealVectorBounds & _bounds = eoDummyVectorNoBounds) :
      eoSortedStat<EOT,  std::vector<double> >(std::vector<double>(0), _description) ,

eo/src/utils/eoStat.h

@@ -57,11 +57,18 @@ public:
 template <class EOT, class T>
 class eoStat : public eoValueParam<T>, public eoStatBase<EOT>
 {
-public :
+public:
-    eoStat(T _value, std::string _description) : eoValueParam<T>(_value, _description) {}
+
-  virtual std::string className(void) const { return "eoStat"; }
+    eoStat(T _value, std::string _description)
+        : eoValueParam<T>(_value, _description)
+        {}
+
+    virtual std::string className(void) const
+        { return "eoStat"; }
 };
 
+
+
 /**
   Base class for statistics calculated over a sorted snapshot of the population
 */
@@ -102,6 +109,9 @@ template <class EOT> class eoAverageStat : public eoStat<EOT, typename EOT::Fitn
 #endif
 {
 public :
+
+    using eoAverageStat< EOT >::value;
+
     typedef typename EOT::Fitness Fitness;
 
     eoAverageStat(std::string _description = "Average Fitness")
@@ -158,10 +168,16 @@ template <class EOT>
 class eoSecondMomentStats : public eoStat<EOT, std::pair<double, double> >
 {
 public :
+
+    using eoSecondMomentStats< EOT >::value;
+
     typedef typename EOT::Fitness fitness_type;
 
     typedef std::pair<double, double> SquarePair;
-    eoSecondMomentStats(std::string _description = "Average & Stdev") : eoStat<EOT, SquarePair>(std::make_pair(0.0,0.0), _description) {}
+
+    eoSecondMomentStats(std::string _description = "Average & Stdev")
+        : eoStat<EOT, SquarePair>(std::make_pair(0.0,0.0), _description)
+        {}
 
     static SquarePair sumOfSquares(SquarePair _sq, const EOT& _eo)
     {
@@ -196,6 +212,8 @@ class eoNthElementFitnessStat : public eoSortedStat<EOT, typename EOT::Fitness >
 #endif
 {
 public :
+    using eoNthElementFitnessStat< EOT >::value;
+
     typedef typename EOT::Fitness Fitness;
 
     eoNthElementFitnessStat(unsigned _whichElement, std::string _description = "nth element fitness")
@@ -298,17 +316,23 @@ template <class EOT>
 class eoBestFitnessStat : public eoStat<EOT, typename EOT::Fitness>
 #endif
 {
-public :
+public:
+
+    using eoBestFitnessStat< EOT >::value;
+
     typedef typename EOT::Fitness Fitness;
 
     eoBestFitnessStat(std::string _description = "Best ")
-      : eoStat<EOT, Fitness>(Fitness(), _description) {}
+        : eoStat<EOT, Fitness>(Fitness(), _description)
+        {}
 
-    void operator()(const eoPop<EOT>& _pop){
+    void operator()(const eoPop<EOT>& _pop) {
         doit(_pop, Fitness() ); // specializations for scalar and std::vector
     }
 
     virtual std::string className(void) const { return "eoBestFitnessStat"; }
+
+
 private :
 
     struct CmpFitness
@@ -353,8 +377,13 @@ private :
 template <class EOT>
 class eoDistanceStat : public eoStat<EOT, double>
 {
-public :
+public:
-    eoDistanceStat(std::string _name = "distance") : eoStat<EOT, double>(0.0, _name) {}
+
+    using eoDistanceStat< EOT >::value;
+
+    eoDistanceStat(std::string _name = "distance")
+        : eoStat<EOT, double>(0.0, _name)
+        {}
 
     template <class T>
     double distance(T a, T b)

eo/src/utils/eoUpdater.h

@@ -70,7 +70,10 @@ private:
 template <class T>
 class eoIncrementorParam : public eoUpdater, public eoValueParam<T>
 {
-public :   
+public:
+
+    using eoIncrementorParam< T >::value;
+
   /** Default Ctor : a name and optionally an increment*/
   eoIncrementorParam( std::string _name, T _stepsize = 1) :
     eoValueParam<T>(T(0), _name), stepsize(_stepsize) {}

eo/src/utils/selectors.h

@@ -104,6 +104,8 @@ double sum_fitness(const eoPop<EOT>& _pop)
 template <class EOT>
 double sum_fitness(const eoPop<EOT>& _pop, std::pair<double, double>& _minmax)
 {
+    double rawTotal, scaledTotal;
+
     typename eoPop<EOT>::const_iterator it = _pop.begin();
 
     _minmax.first = it->fitness();
@@ -114,7 +116,7 @@ double sum_fitness(const eoPop<EOT>& _pop, std::pair<double, double>& _minmax)
         double v = static_cast<double>(it->fitness());
 
         _minmax.first = std::min(_minmax.first, v);
-        _minmax.second = max(_minmax.second, v);
+        _minmax.second = std::max(_minmax.second, v);
 
         rawTotal += v;
     }
@@ -129,10 +131,12 @@ double sum_fitness(const eoPop<EOT>& _pop, std::pair<double, double>& _minmax)
     // unfortunately a second loop is neccessary to scale the fitness
     for (it = _pop.begin(); it != _pop.end(); ++it)
     {
-        double v = scale_fitness(static_cast<double>(it->fitness()));
+        double v = scale_fitness(_minmax, static_cast<double>(it->fitness()));
 
         scaledTotal += v;
     }
+
+    return scaledTotal;
 }
 
 template <class It>

eo/test/t-MGE1bit.cpp

@@ -83,13 +83,10 @@ int main()
   eoEasyEA<Chrom> ea(checkpoint, eval,  breeder, replace);
 
   // evolution
-  try
+  try {
-  {
       ea(pop);
-  }
+  } catch (std::exception& e) {
-  catch (std::exception& e)
+      std::cerr << "exception: " << e.what() << std::endl;;
-  {
-      std::cout << "exception: " << e.what() << std::endl;;
       exit(EXIT_FAILURE);
   }
 
@@ -98,7 +95,14 @@ int main()
       std::cout << "\t" <<  pop[i] << " " << pop[i].fitness() << std::endl;
 
   std::cout << "\n --> Number of Evaluations = " << eval.getValue() << std::endl;
-  return 0;
+  return EXIT_SUCCESS;
 }
 
 //-----------------------------------------------------------------------------
+
+
+
+// Local Variables:
+// mode: C++
+// c-file-style: "Stroustrup"
+// End:

eo/test/t-eoPareto.cpp

@@ -79,18 +79,28 @@ class Init : public eoInit<eoDouble>
   }
 };
 
-// Trying out an elitist non-dominated sorted replacement scheme
+/** @brief An elitist non-dominated sorted replacement scheme.
+
+Trying out an elitist non-dominated sorted replacement scheme.
+*/
 template <class EOT, class WorthT = double>
 class eoNDPlusReplacement : public eoReplacement<EOT>
 {
 public:
-  eoNDPlusReplacement(eoPerf2Worth<EOT, WorthT>& _perf2worth) : perf2worth(_perf2worth) {}
+
+    // using eoNDPlusReplacement< EOT, WorthT >::first;
+
+    eoNDPlusReplacement(eoPerf2Worth<EOT, WorthT>& _perf2worth)
+        : perf2worth(_perf2worth)
+        {}
 
     struct WorthPair : public pair<WorthT, const EOT*>
     {
-    bool operator<(const WorthPair& other) const { return other.first < first; }
+        bool operator<(const WorthPair& other) const
+            { return other.first < this->first; }
     };
 
+
   void operator()(eoPop<EOT>& _parents, eoPop<EOT>& _offspring)
   {
     unsigned sz = _parents.size();
@@ -232,3 +242,9 @@ int main(int argc, char* argv[])
   }
 }
 
+
+
+// Local Variables:
+// mode: C++
+// c-file-style: "Stroustrup"
+// End: