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/app/mastermind/mastermind.cpp

@@ -51,8 +51,8 @@ int main(int argc, char** argv)
     }
   catch (exception& e)
     {
-      cerr << argv[0] << ": " << e.what() << endl;
+        cerr << argv[0] << ": " << e.what() << endl;
-      exit(EXIT_FAILURE);
+        exit(EXIT_FAILURE);
     }
 
   return 0;

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,16 +46,14 @@
 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() {
-  */
+        std::vector<std::vector<bool> >::clear();
-  void clear()
+#warning Is this correct? Was: "fitnesses.clear()"
-  {
+        fitness.clear();
-    std::vector<std::vector<bool> >::clear();
+    }
-    fitnesses.clear();
-  }
 
   /**
     Update or create the dominance map

eo/src/eoLinearFitScaling.h

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

eo/src/eoNDSorting.h

@@ -41,10 +41,13 @@
 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
         Implement to create your own nondominated sorting algorithm. The size of the returned std::vector
@@ -409,21 +412,26 @@ 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;
+    typedef std::pair<double, unsigned> double_index_pair;
 
   class compare_nodes
   {

eo/src/eoOpContainer.h

@@ -87,55 +87,57 @@ class eoOpContainer : public eoGenOp<EOT>
 template <class EOT>
 class eoSequentialOp : public eoOpContainer<EOT>
 {
-  public :
+public:
-  typedef unsigned position_type;
+
+    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();
-    position_type pos = _pop.tellp();
+        for (size_t i = 0; i < rates.size(); ++i) {
+            _pop.seekp(pos);
+            do {
+                if (eo::rng.flip(rates[i])) {
+                    //            try
+                    //            {
+                    // apply it to all the guys in the todo std::list
+                    (*ops[i])(_pop);
+                    //            }
+                    // check for out of individuals and do nothing with that...
+                    //            catch(eoPopulator<EOT>::OutOfIndividuals&)
+                    //	      {
+                    //		std::cout << "Warning: not enough individuals to handle\n";
+                    //		return ;
+                    //	      }
+                }
 
-     for (size_t i = 0; i < rates.size(); ++i)
+                if (!_pop.exhausted())
-     {
+                    ++_pop;
-        _pop.seekp(pos);
+            }
-
+            while (!_pop.exhausted());
-        do
-        {
-          if (eo::rng.flip(rates[i]))
-          {
-	    //            try
-	    //            {
-	      // apply it to all the guys in the todo std::list
-              (*ops[i])(_pop);
-	      //            }
-            // check for out of individuals and do nothing with that...
-	      //            catch(eoPopulator<EOT>::OutOfIndividuals&)
-	      //	      {
-	      //		std::cout << "Warning: not enough individuals to handle\n";
-	      //		return ;
-	      //	      }
-          }
-
-          if (!_pop.exhausted())
-            ++_pop;
         }
-        while (!_pop.exhausted());
+    }
-     }
+    virtual std::string className() const {return "SequentialOp";}
-  }
-  virtual std::string className() const {return "SequentialOp";}
 
-  private :
+private:
 
-  std::vector<size_t> to_apply;
+    std::vector<size_t> to_apply;
-  std::vector<size_t> production;
+    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
-  class compare_worth
-  {
-  public :
-    compare_worth(const std::vector<WorthT>& _worths) : worths(_worths) {}
-
-    bool operator()(unsigned a, unsigned b) const
     {
-      return worths[b] < worths[a]; // sort in descending (!) order
+    public:
-    }
 
-  private :
+        compare_worth(const std::vector<WorthT>& _worths) : worths(_worths) {}
 
-    const std::vector<WorthT>& worths;
+        bool operator()(unsigned a, unsigned b) const {
-  };
+            return worths[b] < worths[a]; // sort in descending (!) order
+        }
 
-  virtual void resize(eoPop<EOT>& _pop, unsigned sz)
+    private:
-  {
+
-    _pop.resize(sz);
+        const std::vector<WorthT>& worths;
-    value().resize(sz);
+    };
-  }
+
+
+
+    virtual void resize(eoPop<EOT>& _pop, unsigned sz) {
+        _pop.resize(sz);
+        value().resize(sz);
+    };
 
 };
 
@@ -106,8 +110,11 @@ Perf2Worth with fitness cache
 template <class EOT, class WorthT = typename EOT::Fitness>
 class eoPerf2WorthCached : public eoPerf2Worth<EOT, WorthT>
 {
-  public:
+public:
-  eoPerf2WorthCached(std::string _description = "Worths") : eoPerf2Worth<EOT, WorthT>(_description) {}
+
+    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;
-      unsigned i;
+        value().resize(_pop.size());
-      value.resize(_pop.size());
+        for (i = 0; i < _pop.size(); ++i)
-      for (i = 0; i < _pop.size(); ++i)
+            value()[i]=_pop[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;
+    eoPop<EOT>& dest;
-  typename eoPop<EOT>::iterator current;
+    typename eoPop<EOT>::iterator current;
-  const eoPop<EOT>& src;
+    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,31 +143,34 @@ 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) :
+    eoSeqPopulator(const eoPop<EOT>& _pop, eoPop<EOT>& _dest) :
-    eoPopulator<EOT>(_pop, _dest), current(0) {}
+        eoPopulator<EOT>(_pop, _dest), current(0) {}
 
-  /** the select method simply returns next individual in the src pop */
+    /** 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();
-      {
+        }
-	throw OutOfIndividuals();
-      }
 
-    const EOT& res = src[current++];
+        const EOT& res = eoPopulator< EOT >::src[current++];
-    return res;
+        return res;
-  }
+    }
 
-private :
+
-  unsigned current;
+private:
+
+    struct OutOfIndividuals {};
+
+    unsigned current;
 };
 
 
@@ -178,20 +181,22 @@ template <class EOT>
 class eoSelectivePopulator : public eoPopulator<EOT>
 {
 public :
-  eoSelectivePopulator(const eoPop<EOT>& _pop, eoPop<EOT>& _dest, eoSelectOne<EOT>& _sel)
+
-    : eoPopulator<EOT>(_pop, _dest), sel(_sel)
+    using eoPopulator< EOT >::src;
-    {
+
-      sel.setup(_pop);
+    eoSelectivePopulator(const eoPop<EOT>& _pop, eoPop<EOT>& _dest, eoSelectOne<EOT>& _sel)
+        : eoPopulator<EOT>(_pop, _dest), sel(_sel)
+        { sel.setup(_pop); };
+
+    /** the select method actually selects one guy from the src pop */
+    const EOT& select() {
+        return sel(src);
     }
 
-  /** the select method actually selects one guy from the src pop */
-  const EOT& select()
-  {
-    return sel(src);
-  }
 
-private :
+private:
-  eoSelectOne<EOT>& sel;
+
+    eoSelectOne<EOT>& sel;
 };
 
 #endif

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,12 +136,11 @@ public:
 
   eoScalarFitnessAssembled& operator=( const ScalarType& v ) {
 
-    if ( empty() )
+      if( empty() )
-      push_back( v );
+          push_back( v );
-    else
+      else
-      front() = v;
+          front() = v;
-  
+      return *this;
-    return *this;
   }
 
   //! Overload push_back()

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
-   */
-  eoSelectFromWorth(eoPerf2Worth<EOT, WorthType> & _perf2Worth) :
-    perf2Worth(_perf2Worth) {}
 
-  /* setup the worthes */
+    /* Default ctor from an eoPerf2Worth object */
-  virtual void setup(const eoPop<EOT>& _pop)
+    eoSelectFromWorth(eoPerf2Worth<EOT, WorthType>& _perf2Worth)
-  {
+        : perf2Worth(_perf2Worth)
-    perf2Worth(_pop);
+        {}
 
+    /* setup the worthes */
+    virtual void setup(const eoPop<EOT>& 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;
+    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");
-    {
+        }
-      throw std::runtime_error("eoSelectFromWorth: fitnesses are not in sync");
     }
-  }
-
 #endif
-
 };
 
 
@@ -95,36 +91,34 @@ template <class EOT, class WorthT = double>
 class eoDetTournamentWorthSelect : public eoSelectFromWorth<EOT, WorthT>
 {
 public:
-  typedef typename std::vector<WorthT>::iterator worthIterator;
 
-  /* Default ctor from an eoPerf2Worth object +  tournament size
+    using eoSelectFromWorth<EOT, WorthT>::perf2Worth;
-   */
-  eoDetTournamentWorthSelect(eoPerf2Worth<EOT, WorthT> &_perf2Worth,
-			     unsigned _tSize) :
-    eoSelectFromWorth<EOT, WorthT>(_perf2Worth), tSize(_tSize) {}
 
-  /* Perform deterministic tournament on worthes
+    typedef typename std::vector<WorthT>::iterator worthIterator;
-     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();
+    /* Default ctor from an eoPerf2Worth object +  tournament size */
+    eoDetTournamentWorthSelect(eoPerf2Worth<EOT, WorthT>& perf2Worth,
+                               unsigned _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);
+        unsigned index = it - perf2Worth.value().begin();
 #ifndef NDEBUG
-  // check whether the stuff is still in sync
+        // 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;
+
+    unsigned tSize;
 };
 
 /** An instance of eoSelectPerf2Worth that does selection from the Worthes
@@ -134,24 +128,25 @@ template <class EOT, class WorthT = double>
 class eoStochTournamentWorthSelect : public eoSelectFromWorth<EOT, WorthT>
 {
 public:
-  typedef typename std::vector<WorthT>::iterator worthIterator;
 
-  /* Default ctor from an eoPerf2Worth object +  tournament rate
+    using eoSelectFromWorth<EOT, WorthT>::perf2Worth;
-   */
+
-  eoStochTournamentWorthSelect(eoPerf2Worth<EOT, WorthT> &_perf2Worth,
+    typedef typename std::vector<WorthT>::iterator worthIterator;
-			     double _tRate) :
+
-    eoSelectFromWorth<EOT, WorthT>(_perf2Worth), tRate(_tRate) {}
+    /* Default ctor from an eoPerf2Worth object +  tournament rate */
+    eoStochTournamentWorthSelect(eoPerf2Worth<EOT, WorthT> &_perf2Worth, 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();
+    unsigned index = it - perf2Worth.value().begin();
 
 #ifndef NDEBUG
   // check whether the stuff is still in sync
@@ -172,12 +167,16 @@ template <class EOT, class WorthT = double>
 class eoRouletteWorthSelect : public eoSelectFromWorth<EOT, WorthT>
 {
 public:
-  typedef typename std::vector<WorthT>::iterator worthIterator;
 
-  /* Default ctor from an eoPerf2Worth object
+    using eoSelectFromWorth<EOT, WorthT>::perf2Worth;
-   */
+
-  eoRouletteWorthSelect(eoPerf2Worth<EOT, WorthT> &_perf2Worth) :
+    typedef typename std::vector<WorthT>::iterator worthIterator;
-    eoSelectFromWorth<EOT, WorthT>(_perf2Worth) {}
+
+
+    /* Default ctor from an eoPerf2Worth object */
+    eoRouletteWorthSelect(eoPerf2Worth<EOT, WorthT> &_perf2Worth)
+        : eoSelectFromWorth<EOT, WorthT>(_perf2Worth)
+        {}
 
   /* We have to override the default behavior to compute the total
    * only once!
@@ -195,18 +194,16 @@ 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().end(),
-			perf2Worth.value().begin(),
+                                        total);
-			perf2Worth.value().end(),
-			total);
 
    unsigned index = it - perf2Worth.value().begin();
 
@@ -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,14 +45,26 @@
 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
     template <class OtherFitnessType>

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,7 +178,10 @@ template<class EOT> class eoOneFifthMutation :
   public eoNormalMutation<EOT>, public eoUpdatable
 {
 public:
-  typedef typename EOT::Fitness Fitness; 
+
+    using eoNormalMutation< EOT >::Sigma;
+
+    typedef typename EOT::Fitness Fitness;
 
   /**
    * (Default) Constructor.

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: