Added changes mainly by Marc

eo/src/Makefile.am

@@ -11,13 +11,14 @@ libeoincdir = $(includedir)/eo
 libeoinc_HEADERS = EO.h eo eo1d.h eo2d.h eo2dVector.h eoAged.h  eoAlgo.h\
 	eoAtomBitFlip.h  eoAtomCreep.h eoAtomMutation.h eoAtomMutator.h \
 	eoAtomRandom.h eoBin.h eoBitOp.h eoBitOpFactory.h eoBreeder.h\
-	eoData.h eoDup.h eoESChrom.h eoESFullChrom.h eoESFullMut.h eoEasyEA.h\
+	eoData.h eoDetTournament.h eoDup.h eoESChrom.h eoESFullChrom.h eoESFullMut.h eoEasyEA.h\
-	eoEvalFunc.h eoEvalFuncPtr.h eoEvaluator.h eoFitTerm.h eoFitness.h\
+	eoEvalFunc.h eoEvalFuncPtr.h eoFitTerm.h eoFitness.h\
 	eoGenTerm.h  eoGeneration.h eoID.h eoInclusion.h eoInsertion.h\
-	eoKill.h eoLottery.h eoMultiMonOp.h eoMutation.h eoNegExp.h\
+	eoKill.h eoLottery.h eoMerge.h eoMultiBinOp.h eoMultiMonOp.h eoMutation.h eoNegExp.h\
 	eoNonUniform.h eoNormal.h eoObject.h  eoOp.h  eoOpSelector.h\
 	eoParser.h  eoPersistent.h  eoPop.h eoPopOps.h  eoPrintable.h\
 	eoProblem.h eoProportionalOpSel.h eoRNG.h eoRnd.h  eoString.h\
-	eoTerm.h eoTranspose.h eoUniform.h eoVector.h eoXOver2.h 
+	eoStochTournament.h eoTerm.h eoTranspose.h eoUniform.h \
+	eoUniformSelect.h eoUniformXOver.h eoVector.h eoXOver2.h 
 
 

eo/src/eo

@@ -48,21 +48,23 @@
 
 #include <eoOp.h>
 #include <eoMultiMonOp.h>
+#include <eoMultiBinOp.h>
 
 #include <eoDup.h>
 #include <eoKill.h>
 #include <eoTranspose.h>
 #include <eoXOver2.h>
+#include <eoUniformXOver.h>
 #include <eoMutation.h>
 
 #include <eoPop.h>
 #include <eoPopOps.h>
+#include <eoMerge.h>
 #include <eoBitOp.h>
 
 // Evaluation functions
 #include <eoEvalFunc.h>
 #include <eoEvalFuncPtr.h>
-#include <eoEvaluator.h>
 
 // Terminators
 #include <eoTerm.h>
@@ -70,6 +72,9 @@
 #include <eoFitTerm.h>
 
 // Selection and reproduction stuff
+#include <eoUniformSelect.h>
+#include <eoDetTournament.h>
+#include <eoStochTournament.h>
 #include <eoLottery.h>
 #include <eoBreeder.h>
 #include <eoInsertion.h>

eo/src/eoAtomBitFlip.h

@@ -1,7 +1,7 @@
 // -*- mode: c++; c-indent-level: 4; c++-member-init-indent: 8; comment-column: 35; -*-
 
 //-----------------------------------------------------------------------------
-// eoAtomCreep.h
+// eoAtomBitFlip.h
 //   Increments or decrements by one a single element
 // (c) GeNeura Team, 1998
 /* 
@@ -22,8 +22,8 @@
     Contact: todos@geneura.ugr.es, http://geneura.ugr.es
  */
 //-----------------------------------------------------------------------------
-#ifndef _EOATOMCREEP_H
+#ifndef _EOATOMBITFLIP_H
-#define _EOATOMCREEP_H
+#define _EOATOMBITFLIP_H
 
 /** Flips a single bit
 */

eo/src/eoBitOp.h

@@ -318,39 +318,6 @@ template<class Chrom> class eoBinGxOver: public eoBinOp<Chrom>
 };
 
 
-/** eoBinUxOver --> uniform crossover */
-
-template<class Chrom> class eoBinUxOver: public eoBinOp<Chrom>
-{
-public:
-  /// (Default) Constructor.
-  eoBinUxOver(const float _rate = 0.5): rate(_rate)
-    { 
-      if (rate < 0 || rate > 1)
-	runtime_error("UxOver --> invalid rate");
-    }
-  
-  /// The class name.
-  string className() const { return "eoBinUxOver"; }
-  
-  /**
-   * Uniform crossover for binary chromosomes.
-   * @param chrom1 The first chromosome.
-   * @param chrom2 The first chromosome.
-   */
-  void operator()(Chrom& chrom1, Chrom& chrom2) const
-    {
-      unsigned min_size = min(chrom1.size(), chrom2.size());
-      eoUniform<float> uniform(0, 1);
-      
-      for (unsigned bit = 0; bit < min_size; bit++)
-	if (uniform() < rate)
-	  swap(chrom1[bit], chrom2[bit]);
-    }
-  
- public:
-  float rate;
-};
 
 //-----------------------------------------------------------------------------
 //@}

eo/src/eoBreeder.h

@@ -1,5 +1,26 @@
+// -*- mode: c++; c-indent-level: 4; c++-member-init-indent: 8; comment-column: 35; -*-
+
 //-----------------------------------------------------------------------------
 // eoBreeder.h
+//   Takes two populations and mixes them
+// (c) GeNeura Team, 1998
+/* 
+   This library is free software; you can redistribute it and/or
+   modify it under the terms of the GNU Lesser General Public
+   License as published by the Free Software Foundation; either
+   version 2 of the License, or (at your option) any later version.
+
+   This library is distributed in the hope that it will be useful,
+   but WITHOUT ANY WARRANTY; without even the implied warranty of
+   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+   Lesser General Public License for more details.
+
+   You should have received a copy of the GNU Lesser General Public
+   License along with this library; if not, write to the Free Software
+   Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+
+   Contact: todos@geneura.ugr.es, http://geneura.ugr.es
+ */
 //-----------------------------------------------------------------------------
 
 #ifndef eoBreeder_h
@@ -21,7 +42,7 @@ using namespace std;
  * For every operator there is a rated to be applyed.                        *
  *****************************************************************************/
 
-template<class Chrom> class eoBreeder: public eoTransform<Chrom>
+template<class Chrom> class eoBreeder: public eoMonPopOp<Chrom>
 {
  public:
   /// Default constructor.

eo/src/eoDetTournament.h

@@ -0,0 +1,78 @@
+// -*- mode: c++; c-indent-level: 4; c++-member-init-indent: 8; comment-column: 35; -*-
+
+//-----------------------------------------------------------------------------
+// eoDetTournament.h
+// (c) GeNeura Team, 1998 - EEAAX 1999
+/* 
+    This library is free software; you can redistribute it and/or
+    modify it under the terms of the GNU Lesser General Public
+    License as published by the Free Software Foundation; either
+    version 2 of the License, or (at your option) any later version.
+
+    This library is distributed in the hope that it will be useful,
+    but WITHOUT ANY WARRANTY; without even the implied warranty of
+    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+    Lesser General Public License for more details.
+
+    You should have received a copy of the GNU Lesser General Public
+    License along with this library; if not, write to the Free Software
+    Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+
+    Contact: todos@geneura.ugr.es, http://geneura.ugr.es
+             Marc.Schoenauer@polytechnique.fr
+ */
+//-----------------------------------------------------------------------------
+
+#ifndef eoDetTournament_h
+#define eoDetTournament_h
+
+//-----------------------------------------------------------------------------
+
+#include <functional>  // 
+#include <numeric>     // accumulate
+#include <eoPopOps.h>          // eoPop eoSelect MINFLOAT
+#include <eoRNG.h>
+
+//-----------------------------------------------------------------------------
+/** eoDetTournament: a selection method that selects ONE individual by
+ deterministic tournament 
+ -MS- 24/10/99 */
+//-----------------------------------------------------------------------------
+
+template <class EOT> class eoDetTournament: public eoSelectOne<EOT>
+{
+ public:
+  /// (Default) Constructor.
+  eoDetTournament(unsigned _Tsize = 2 ):eoSelectOne(), Tsize(_Tsize) {
+    // consistency check
+    if (Tsize < 2) {
+      cout << "Warning, Tournament size shoudl be >= 2\nAdjusted\n";
+      Tsize = 2;
+    }
+  }
+  
+  /** DANGER: if you want to be able to minimize as well as maximizem
+      DON'T cast the fitness to a float, use the EOT comparator! */
+  virtual const EOT& operator()(const eoPop<EOT>& pop) {
+    unsigned best = rng.random(pop.size());		// random individual
+    
+    for (unsigned i = 0; i<Tsize-1; i++) {
+      unsigned tmp = rng.random(pop.size());
+      if (pop[best] < pop[tmp])
+	best = tmp;
+    }
+    return pop[best] ;
+  }
+
+  /** Inherited from eoObject 
+      @see eoObject
+  */
+  string className() const {return "eoDetTournament";};
+  
+ private:
+  unsigned Tsize;
+};
+
+//-----------------------------------------------------------------------------
+
+#endif eoDetTournament_h

eo/src/eoESFullChrom.h

@@ -119,9 +119,9 @@ class eoESFullChrom  : public eoVector<double, fitT> {
       cout << "WARNING, Number of Standard Deviations > Number of Object Variables\nAdjusted!\n";
       num_sigma = num_genes;
       // modify the Param value - so .status is OK
-      char sloc[20];
+      ostrstream sloc;
-      sprintf(sloc, "%d", num_genes);
+      sloc << num_genes;
-      parser.setParamValue("--NbSigma", sloc);
+      parser.setParamValue("--NbSigma", sloc.str());
     }
     // adjust the sizes!!!
     resize(num_genes);

eo/src/eoEasyEA.h

@@ -41,9 +41,9 @@ template<class Chrom> class eoEasyEA: public eoAlgo<Chrom>
 {
  public:
   /// Constructor.
-  eoEasyEA(eoSelect<Chrom>&    _select, 
+  eoEasyEA(eoBinPopOp<Chrom>&    _select, 
-	   eoTransform<Chrom>& _transform, 
+	   eoMonPopOp<Chrom>& _transform, 
-	   eoMerge<Chrom>&     _replace,
+	   eoBinPopOp<Chrom>&     _replace,
 	   eoEvalFunc<Chrom>& _evaluator,
 	   eoTerm<Chrom>&     _terminator)
     :step(_select, _transform, _replace, _evaluator), 

eo/src/eoEvalFunc.h

@@ -43,7 +43,7 @@ template<class EOT> struct eoEvalFunc {
 	typedef typename EOT::Fitness EOFitT;
 #endif
 
-  /// Effectively applies the evaluation function to an EO or urEO
+  /// Effectively applies the evaluation function to an EO 
   virtual void operator() ( EOT & _eo ) const = 0;
 };
 

eo/src/eoEvaluator.h

@@ -1,72 +0,0 @@
-// -*- mode: c++; c-indent-level: 4; c++-member-init-indent: 8; comment-column: 35; -*-
-
-//-----------------------------------------------------------------------------
-// eoEvaluator.h
-// (c) GeNeura Team, 1998
-/* 
-    This library is free software; you can redistribute it and/or
-    modify it under the terms of the GNU Lesser General Public
-    License as published by the Free Software Foundation; either
-    version 2 of the License, or (at your option) any later version.
-
-    This library is distributed in the hope that it will be useful,
-    but WITHOUT ANY WARRANTY; without even the implied warranty of
-    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
-    Lesser General Public License for more details.
-
-    You should have received a copy of the GNU Lesser General Public
-    License along with this library; if not, write to the Free Software
-    Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
-
-    Contact: todos@geneura.ugr.es, http://geneura.ugr.es
- */
-//-----------------------------------------------------------------------------
-
-#ifndef _EOEVALUATOR_H
-#define _EOEVALUATOR_H
-
-//-----------------------------------------------------------------------------
-#include <eoPopOps.h>
-#include <eoEvalFunc.h>
-
-//-----------------------------------------------------------------------------
-/** Evaluator takes a vector of EOs and evaluates its fitness
-* returning void. Template instances must be of fitness and EO type
-*/
-template<class EOT>
-class eoEvaluator: public eoTransform<EOT>{
-public:
-	/// ctor
-	eoEvaluator( const eoEvalFunc< EOT> & _ef )
-		: eoTransform<EOT>(), repEF( _ef ){};
-
-	/// Needed virtual destructor
-	virtual ~eoEvaluator() {};
-
-	/* Sets the evaluation function
-	virtual void EF( const eoEvalFunc< EOT> & _ef ) { repEF= _ef;};*/
-
-	/// Gets the evaluation function
-	virtual const eoEvalFunc< EOT>& EF() { return repEF;};
-
-	/** This is the actual function operator(); it is left without implementation.
-		It takes a vector of pointers to eo
-	 * @param _vEO is a vector of pointers to eo, that will be evaluated
-	 */
-
-  virtual void operator() ( EOT& _eot ) const = 0;
-
-	///@name eoObject methods
-	//@{
-	/** Return the class id */
-	virtual string className() const { return "eoEvaluator"; }
-
-	/** Read and print are left without implementation */
-	//@}
-	
-private:
-	const eoEvalFunc< EOT> & repEF; 
-};
-//@}
-
-#endif

eo/src/eoGeneration.h

@@ -39,9 +39,9 @@ template<class Chrom> class eoGeneration: public eoAlgo<Chrom>
 {
  public:
   /// Constructor.
-  eoGeneration(eoSelect<Chrom>&    _select, 
+  eoGeneration(eoBinPopOp<Chrom>&    _select, 
-	       eoTransform<Chrom>& _transform, 
+	       eoMonPopOp<Chrom>& _transform, 
-	       eoMerge<Chrom>&     _replace,
+	       eoBinPopOp<Chrom>&     _replace,
 	       eoEvalFunc<Chrom>& _evaluator):
     select(_select), transform(_transform), 
     replace(_replace), evaluator( _evaluator) {};
@@ -69,9 +69,9 @@ template<class Chrom> class eoGeneration: public eoAlgo<Chrom>
   string className() const { return "eoGeneration"; }
   
  private:
-  eoSelect<Chrom>&    select;
+  eoBinPopOp<Chrom>&    select;
-  eoTransform<Chrom>& transform;
+  eoMonPopOp<Chrom>& transform;
-  eoMerge<Chrom>&     replace;
+  eoBinPopOp<Chrom>&     replace;
   eoEvalFunc<Chrom>& evaluator;
 };
 

eo/src/eoInclusion.h

@@ -7,8 +7,11 @@
 
 //-----------------------------------------------------------------------------
 
-#include <eoPop.h>    // eoPop 
+#include <iostream>
-#include <eoPopOps.h> // eoMerge
+
+// EO includes
+#include <eoPop.h>    
+#include <eoMerge.h>
 
 /*****************************************************************************
  * eoInclusion: A replacement algorithm.                                     *
@@ -20,7 +23,13 @@ template<class Chrom> class eoInclusion: public eoMerge<Chrom>
 {
  public:
   /// (Default) Constructor.
-  eoInclusion(const float& _rate = 1.0): eoMerge<Chrom>(_rate) {}
+  eoInclusion(const float& _rate = 1.0): eoMerge<Chrom>( _rate ) {}
+
+  /// Ctor from istream
+  eoInclusion( istream& _is): eoBinPopOp<Chrom>( _is ) {};
+
+  /// Dtor
+  virtual ~eoInclusion() {};
 
   /**
    * Creates a new population based on breeders and original populations.
@@ -38,6 +47,16 @@ template<class Chrom> class eoInclusion: public eoMerge<Chrom>
 		   greater<Chrom>());
       pop.erase(pop.begin() + target, pop.end());
     }
+
+  /** @name Methods from eoObject	*/
+  //@{
+  /** readFrom and printOn inherited from eoMerge */
+  
+  /** Inherited from eoObject. Returns the class name.
+      @see eoObject
+  */
+  virtual string className() const {return "eoMerge";};
+  //@}
 };
 
 //-----------------------------------------------------------------------------

eo/src/eoInsertion.h

@@ -1,5 +1,26 @@
+// -*- mode: c++; c-indent-level: 4; c++-member-init-indent: 8; comment-column: 35; -*-
+
 //-----------------------------------------------------------------------------
 // eoInsertion.h
+//   Inserts new members into the population
+// (c) GeNeura Team, 1998
+/* 
+   This library is free software; you can redistribute it and/or
+   modify it under the terms of the GNU Lesser General Public
+   License as published by the Free Software Foundation; either
+   version 2 of the License, or (at your option) any later version.
+
+   This library is distributed in the hope that it will be useful,
+   but WITHOUT ANY WARRANTY; without even the implied warranty of
+   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+   Lesser General Public License for more details.
+
+   You should have received a copy of the GNU Lesser General Public
+   License along with this library; if not, write to the Free Software
+   Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+
+   Contact: todos@geneura.ugr.es, http://geneura.ugr.es
+ */
 //-----------------------------------------------------------------------------
 
 #ifndef eoInsertion_h
@@ -7,8 +28,11 @@
 
 //-----------------------------------------------------------------------------
 
+#include <iostream>
+
+// EO includes
 #include <eoPop.h>     // eoPop
-#include <eoPopOps.h>  // eoMerge
+#include <eoMerge.h>  // eoMerge
 
 /******************************************************************************
  * eoInsertion: A replacement algorithm.
@@ -20,58 +44,51 @@ template<class Chrom> class eoInsertion: public eoMerge<Chrom>
 {
  public:
   /// (Default) Constructor.
-  eoInsertion(const float& _rate = 1.0): eoMerge<Chrom>(_rate) {}
+  eoInsertion(const float& _rate = 1.0): eoMerge<Chrom>( _rate ) {}
+
+  /// Ctor from istream
+  eoInsertion( istream& _is): eoBinPopOp<Chrom>( _is ) {};
+
+  /// Dtor
+  virtual ~eoInsertion() {};
 
   /**
    * Creates a new population based on breeders and original populations.
-   * @param breeders The population of breeders.
+   * @param breeders The population of breeders. Should be sorted to work correctly
    * @param pop The original population.
    */
-  /*void operator()(eoPop<Chrom>& breeders, eoPop<Chrom>& pop)
+  void operator()( eoPop<Chrom>& _breeders, eoPop<Chrom>& _pop)
     {
-      int new_size = static_cast<int>(pop.size() * rate());
+      unsigned target = static_cast<unsigned>(rint(_pop.size() * rate()));
       
-      if (new_size == breeders.size())
+      _pop.swap(_breeders);
-	{
-	  pop = breeders;
-	}
-      else if (new_size < breeders.size())
-	{
-	  pop = breeders;
-	  sort(pop.begin(), pop.end());
-	  pop.erase(pop.begin(), pop.begin() - new_size + pop.size());
-	}
-      else
-	{
-	  sort(pop.begin(), pop.end());
-	  pop.erase(pop.begin(), 
-		    pop.begin() + breeders.size() + pop.size() - new_size);
-	  copy(breeders.begin(), breeders.end(), 
-	       back_insert_iterator<eoPop<Chrom> >(pop));
-	}
-	}*/
       
-  void operator()(eoPop<Chrom>& breeders, eoPop<Chrom>& pop)
+      if (target < _pop.size())
-    {
-      unsigned target = static_cast<unsigned>(rint(pop.size() * rate()));
-      
-      pop.swap(breeders);
-      
-      if (target < pop.size())
 	{
-	  partial_sort(pop.begin(), pop.begin() + target, pop.end(), 
+	  partial_sort(_pop.begin(), _pop.begin() + target, _pop.end(), 
 		       greater<Chrom>());
-	  pop.erase(pop.begin() + target, pop.end());
+	  _pop.erase(_pop.begin() + target, _pop.end());
 	}
       else
 	{
-	  target = min(target - pop.size(), breeders.size());
+	  target = min(target - _pop.size(), _breeders.size());
-	  partial_sort(breeders.begin(), breeders.begin() + target, 
+	  partial_sort(_breeders.begin(), _breeders.begin() + target, 
-		       breeders.end(), greater<Chrom>());
+		       _breeders.end(), greater<Chrom>());
-	  copy(breeders.begin(), breeders.begin() + target,
+	  copy(_breeders.begin(), _breeders.begin() + target,
-	       back_insert_iterator<eoPop<Chrom> >(pop));
+	       back_insert_iterator<eoPop<Chrom> >(_pop));
 	}
-    }
+    };
+
+  /** @name Methods from eoObject	*/
+  //@{
+  /** readFrom and printOn inherited from eoMerge */
+
+  /** Inherited from eoObject. Returns the class name.
+      @see eoObject
+  */
+  virtual string className() const {return "eoInsertion";};
+  //@}
+
 };
 
 //-----------------------------------------------------------------------------

eo/src/eoLottery.h

@@ -1,5 +1,26 @@
+// -*- mode: c++; c-indent-level: 4; c++-member-init-indent: 8; comment-column: 35; -*-
+
 //-----------------------------------------------------------------------------
 // eoLottery.h
+//   Implements the lottery procedure for selection
+// (c) GeNeura Team, 1998
+/* 
+    This library is free software; you can redistribute it and/or
+    modify it under the terms of the GNU Lesser General Public
+    License as published by the Free Software Foundation; either
+    version 2 of the License, or (at your option) any later version.
+
+    This library is distributed in the hope that it will be useful,
+    but WITHOUT ANY WARRANTY; without even the implied warranty of
+    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+    Lesser General Public License for more details.
+
+    You should have received a copy of the GNU Lesser General Public
+    License along with this library; if not, write to the Free Software
+    Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+
+    Contact: todos@geneura.ugr.es, http://geneura.ugr.es
+ */
 //-----------------------------------------------------------------------------
 
 #ifndef eoLottery_h
@@ -16,14 +37,14 @@
 /// requires Chrom::Fitness to be float castable
 //-----------------------------------------------------------------------------
 
-template<class Chrom> class eoLottery: public eoSelect<Chrom>
+template<class Chrom> class eoLottery: public eoBinPopOp<Chrom>
 {
  public:
   /// (Default) Constructor.
   eoLottery(const float& _rate = 1.0): rate(_rate) {}
   
   /// 
-  void operator()(const eoPop<Chrom>& pop, eoPop<Chrom>& breeders) const
+  void operator()( eoPop<Chrom>& pop, eoPop<Chrom>& breeders) 
     {
       // scores of chromosomes
       vector<float> score(pop.size());

eo/src/eoMerge.h

@@ -0,0 +1,115 @@
+// -*- mode: c++; c-indent-level: 4; c++-member-init-indent: 8; comment-column: 35; -*-
+
+//-----------------------------------------------------------------------------
+// eoMerge.h
+//   Base class for population-merging classes
+// (c) GeNeura Team, 1998
+/* 
+   This library is free software; you can redistribute it and/or
+   modify it under the terms of the GNU Lesser General Public
+   License as published by the Free Software Foundation; either
+   version 2 of the License, or (at your option) any later version.
+
+   This library is distributed in the hope that it will be useful,
+   but WITHOUT ANY WARRANTY; without even the implied warranty of
+   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+   Lesser General Public License for more details.
+
+   You should have received a copy of the GNU Lesser General Public
+   License along with this library; if not, write to the Free Software
+   Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+
+   Contact: todos@geneura.ugr.es, http://geneura.ugr.es
+ */
+//-----------------------------------------------------------------------------
+
+#ifndef eoMerge_h
+#define eoMerge_h
+
+//-----------------------------------------------------------------------------
+
+#include <iostream>
+
+// EO includes
+#include <eoPop.h>     // eoPop
+#include <eoPopOps.h>  // eoMerge
+
+/**
+ * eoMerge: Base class for replacement algorithms
+ */
+
+template<class Chrom> class eoMerge: public eoBinPopOp<Chrom>
+{
+ public:
+  /// (Default) Constructor.
+  eoMerge(const float& _rate = 1.0): eoBinPopOp<Chrom>(), repRate( _rate ) {}
+
+  /// Ctor from istream
+  eoMerge( istream& _is): eoBinPopOp<Chrom>() { readFrom( _is ); };
+ 
+  /**
+   * Creates a new population based on breeders and original populations.
+   * @param breeders The population of breeders. Should be sorted to work correctly
+   * @param pop The original population.
+   */
+  void operator()( eoPop<Chrom>& _breeders, eoPop<Chrom>& _pop)
+    {
+      unsigned target = static_cast<unsigned>(rint(_pop.size() * rate()));
+      
+      _pop.swap(_breeders);
+      
+      if (target < _pop.size())
+	{
+	  partial_sort(_pop.begin(), _pop.begin() + target, _pop.end(), 
+		       greater<Chrom>());
+	  _pop.erase(_pop.begin() + target, _pop.end());
+	}
+      else
+	{
+	  target = min(target - _pop.size(), _breeders.size());
+	  partial_sort(_breeders.begin(), _breeders.begin() + target, 
+		       _breeders.end(), greater<Chrom>());
+	  copy(_breeders.begin(), _breeders.begin() + target,
+	       back_insert_iterator<eoPop<Chrom> >(_pop));
+	}
+    };
+
+  /** @name Methods from eoObject	*/
+  //@{
+  /**
+   * Read object. The EOT class must have a ctor from a stream;
+   in this case, a strstream is used.
+   * @param _is A istream.
+   
+   */
+  virtual void readFrom(istream& _is) {
+    _is >> repRate;
+  }
+  
+  /**
+   * Write object. Prints relevant parameters to standard output
+   * @param _os A ostream. In this case, prints the population to
+   standard output. The EOT class must hav standard output with cout,
+   but since it should be an eoObject anyways, it's no big deal.
+   */
+  virtual void printOn(ostream& _os) const {
+    _os << repRate;
+  };
+
+  /** Inherited from eoObject. Returns the class name.
+      @see eoObject
+  */
+  virtual string className() const {return "eoMerge";};
+  //@}
+
+ protected:
+  float rate() { return repRate;};
+
+ private:
+  float repRate;
+
+};
+
+//-----------------------------------------------------------------------------
+
+#endif eoInsertion_h

eo/src/eoMultiBinOp.h

@@ -0,0 +1,99 @@
+// -*- mode: c++; c-indent-level: 4; c++-member-init-indent: 8; comment-column: 35; -*-
+
+//-----------------------------------------------------------------------------
+// eoMultiBinOp.h
+//   Class that combines several binary or unary operators
+// (c) GeNeura Team, 1998
+/* 
+    This library is free software; you can redistribute it and/or
+    modify it under the terms of the GNU Lesser General Public
+    License as published by the Free Software Foundation; either
+    version 2 of the License, or (at your option) any later version.
+
+    This library is distributed in the hope that it will be useful,
+    but WITHOUT ANY WARRANTY; without even the implied warranty of
+    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+    Lesser General Public License for more details.
+
+    You should have received a copy of the GNU Lesser General Public
+    License along with this library; if not, write to the Free Software
+    Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+
+    Contact: todos@geneura.ugr.es, http://geneura.ugr.es
+ */
+//-----------------------------------------------------------------------------
+
+#ifndef _EOMULTIBINOP_h
+#define _EOMULTIBINOP_h
+
+#include <iterator>
+
+#include <eoOp.h>
+
+/** MultiMonOp combines several monary operators. By itself, it does nothing to the
+EO it´s handled*/
+template <class EOT>
+class eoMultiBinOp: public eoBinOp<EOT>  {
+public:
+  /// Ctor from an already existing op
+  eoMultiBinOp( const eoBinOp<EOT>* _op )
+    : eoBinOp< EOT >( ), vOp(){
+    vOp.push_back( _op );
+  };
+
+  ///
+  eoMultiBinOp( )
+    : eoBinOp< EOT >( ), vOp(){};
+
+  /// Ads a new operator
+  void adOp( const eoOp<EOT>* _op ){
+    vOp.push_back( _op );
+  };
+
+  /// needed virtual dtor
+  virtual ~eoMultiBinOp() {};
+  
+  ///
+  /// Applies all operators to the EO
+  virtual void operator()( EOT& _eo1, EOT& _eo2 ) const {
+    if ( vOp.begin() != vOp.end() ) {  // which would mean it's empty
+      for ( vector< const eoOp<EOT>* >::const_iterator i = vOp.begin(); 
+	    i != vOp.end(); i++ ) {
+	// Admits only unary or binary operator
+	switch ((*i)->readArity()) {
+	case unary:
+	  {
+	    const eoMonOp<EOT>* monop = static_cast<const eoMonOp<EOT>* >(*i);
+	    (*monop)( _eo1 );
+	    (*monop)( _eo2 );
+	    break;
+	  }
+	case binary:
+	  {
+	    const eoBinOp<EOT>* binop = static_cast<const eoBinOp<EOT>* >(*i);
+	    (*binop)( _eo1, _eo2 );
+	    break;
+	  }
+	}
+      }
+    }
+  }
+  
+  
+  /** @name Methods from eoObject
+      readFrom and printOn are directly inherited from eoOp
+  */
+  //@{
+  /** Inherited from eoObject 
+      @see eoObject
+  */
+  string className() const {return "eoMultiBinOp";};
+  //@}
+
+private:
+
+  /// uses pointers to base class since operators can be unary or binary
+  vector< const eoOp<EOT>* > vOp;
+};
+
+#endif

eo/src/eoParser.h

@@ -833,7 +833,7 @@ void InitRandom( Parser & parser) {
     }
 
   if (_seed == 0) {		   // use clock to get a "random" seed
-   _seed = unsigned long( time( 0 ) );
+   _seed = (unsigned long)( time( 0 ) );
    ostrstream s;
    s << _seed;
    parser.setParamValue("--seed", s.str());	   // so it will be printed out in the status file, and canbe later re-used to re-run EXACTLY the same run

eo/src/eoPop.h

@@ -28,9 +28,7 @@
 #include <vector>
 #include <strstream>
 
-using namespace std;
+// EO includes
-// from file
-
 #include <eoRnd.h>
 #include <eoPersistent.h>
 
@@ -62,8 +60,7 @@ class eoPop: public vector<EOT>, public eoObject, public eoPersistent {
 	/** Protected ctor. This is intended to avoid creation of void populations, except 
 	    from sibling classes
 	*/
-	eoPop()
+	eoPop()	  :vector<EOT>() {};
-	  :vector<EOT>() {};
 	
 	
 	 /** Ctor for fixed-size chromosomes, with variable content