Added new files to the brew, mainly distance and new-op-interface related

eo/configure.in

@@ -1,6 +1,7 @@
 AC_INIT(src/eo)
 
-AM_INIT_AUTOMAKE(eo, 0.0.8)
+dnl Change the version number here
+AM_INIT_AUTOMAKE(eo)
 
 AC_PROG_CXX
 
@@ -10,4 +11,5 @@ AM_PROG_LIBTOOL
 
 AM_MAINTAINER_MODE
 
+dnl add Makefiles that must be modified by the configuration here
 AC_OUTPUT(Makefile src/Makefile test/Makefile win/Makefile)

eo/src/Makefile.am

@@ -5,22 +5,25 @@
 ###############################################################################
 
 lib_LIBRARIES = libeo.a
-libeo_a_SOURCES =  eoPrintable.cpp eoPersistent.cpp eoParserUtils.cpp
+libeo_a_SOURCES =  eoPrintable.cpp eoPersistent.cpp
 
 libeoincdir = $(includedir)/eo
-libeoinc_HEADERS = EO.h eo eo1d.h eo2d.h eo2dVector.h eoAged.h  eoAlgo.h\
+libeoinc_HEADERS = EO.h eo eo1d.h eo1dWDistance.h eo2d.h \
+	eo2dVector.h eoAged.h  eoAlgo.h\
+	eoAltBreeder.h eoAltProportionalOpSel.h\
 	eoAtomBitFlip.h  eoAtomCreep.h eoAtomMutation.h eoAtomMutator.h \
 	eoAtomRandom.h eoBin.h eoBitOp.h eoBitOpFactory.h eoBreeder.h\
-	eoData.h eoDetTournament.h eoDup.h eoESChrom.h eoESFullChrom.h \
+	eoData.h eoDetTournament.h eoDistance.h eoDup.h eoESChrom.h \
-	eoESFullMut.h eoEasyEA.h\
+	eoESFullChrom.h eoESFullMut.h eoEasyEA.h\
-	eoEvalFunc.h eoEvalFuncPtr.h eoFitTerm.h eoFitness.h\
+	eoEvalFunc.h eoEvalFuncPtr.h eoEvalFuncPtrCnt.h eoFitTerm.h eoFitness.h\
-	eoGenTerm.h  eoGeneration.h eoID.h eoInclusion.h eoInsertion.h\
+	eoGenTerm.h  eoGeneralOp.h eoGeneration.h eoGOpSelector.h eoID.h\
-	eoKill.h eoLottery.h eoMerge.h eoMultiBinOp.h eoMultiMonOp.h \
+	eoInclusion.h eoInsertion.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\
+	eoProblem.h eoProportionalGOpSel.h eoProportionalOpSel.h eoRNG.h\
+	eoRnd.h  eoString.h\
 	eoStochTournament.h eoTerm.h eoTranspose.h eoUniform.h \
-	eoUniformSelect.h eoUniformXOver.h eoVector.h eoXOver2.h \
+	eoUniformSelect.h eoUniformXOver.h eoVector.h eoXOver2.h 
-	eoParserUtils.h
+
 

eo/src/eo1d.h

@@ -1,9 +1,11 @@
-// -*- mode: c++; c-indent-level: 4; c++-member-init-indent: 8; comment-column: 35; -*-
+/* -*- mode: c++; c-indent-level: 4; c++-member-init-indent: 8; comment-column: 35; -*-
+
+   -----------------------------------------------------------------------------
+   eo1d.h 
+       Serial EO.
+
+   (c) GeNeura Team, 1998
  
-//-----------------------------------------------------------------------------
-// eo1d.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
@@ -43,7 +45,6 @@ using namespace std;
  */
 
 //@{
-
 /** eo1d: Base class for "chromosomes" with a single dimension
 #T# is the type it will be instantiated with; this type must have, at
 least, a copy ctor, assignment operators, 

eo/src/eo1dWDistance.h

@@ -0,0 +1,136 @@
+/* -*- mode: c++; c-indent-level: 4; c++-member-init-indent: 8; comment-column: 35; -*-
+
+   -----------------------------------------------------------------------------
+   eo1dWDistance.h 
+       Serial EO with distances. Acts as a wrapper for normal eo1ds
+
+   (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 _EO1DWDISTANCE_H
+#define _EO1DWDISTANCE_H
+
+#include <iostream>				// for ostream
+
+// EO Includes
+#include <eo1d.h>
+#include <eoDistance.h>
+
+using namespace std;
+
+/** eo1dWDistance: wraps around eo1ds and adds the possibility of computing distances
+around them.
+*/
+template<class T, class fitnessT = float>
+class eo1dWDistance: 
+  public eo1d< T,fitnessT >, 
+  public eoDistance<eo1d<T,fitnessT> > {
+public:
+
+  /** Can be used as default ctor; should be called from derived
+      classes. Fitness should be  at birth
+  */
+  eo1dWDistance( eo1d<T,fitnessT>& _eo)
+    :eo1d<T,fitnessT> (), eoDistance< eo1d<T,fitnessT> >(), innereo1d( _eo ) {};
+
+  /// Needed virtual dtor
+  virtual ~eo1dWDistance(){};
+
+  /** Reads and returns a copy of the gene in position _i
+      This implies that T must have a copy ctor .
+      @param _i index of the gene, which is the minimal unit. Must be
+      an unsigned less than #length()#  
+      @return what's inside the gene, with the correct type
+	  @exception out_of_range if _i > size()
+    */
+  virtual T getGene( unsigned _i ) const {
+    return innereo1d.getGene( _i );
+  };
+
+  /** Overwrites the gene placed in position _i with a
+   * new value. This means that the assignment operator
+   * for T must be defined .
+   @param _i index
+   @return what's inside the gene, with the correct type
+   @exception out_of_range if _i > size()
+  */
+  virtual void setGene( unsigned _i, const T& _value ) {
+    innereo1d.setGene( _i, _value);
+  };
+
+  /** Inserts a gene, moving the rest to the right. If
+   * _i = length(), it should insert it at the end.
+   * Obviously, changes length 
+   @param _i index
+   @param _val new value
+  */
+  virtual void insertGene( unsigned _i, T _val )  {
+    innereo1d.insertGene( _i, _val);
+  }
+
+  /** Eliminates the gene at position _i; all the other genes will
+      be shifted left
+      @param _i index of the gene that is going to be modified.
+  */
+  virtual void deleteGene( unsigned _i ) {
+    innereo1d.deleteGene( _i );
+  }
+
+  /// Returns the number of genes in the eo1d
+  virtual unsigned length() const {
+    return innereo1d.length();
+  }
+
+  /// Returns the distance from this EO to the other
+  virtual double distance( const eo1d<T,fitnessT>& _eo ) const {
+    double tmp = 0;
+    // Which one is shorter
+    unsigned len = (innereo1d.length() < _eo.length()) ? _eo.length():innereo1d.length();
+
+    // Compute over the whole length. If it does not exists, it counts as 0
+    for ( unsigned i = 0; i < len; i ++ ) {
+      T val1, val2;
+      val1 = ( i > innereo1d.length())?0:innereo1d.getGene(i);
+      val2 = ( i > _eo.length() )?0:_eo.getGene(i);
+      double diff = val1 - val2;
+      tmp += diff*diff;
+    }
+    return tmp;
+  }
+
+  /** Inherited from eoObject 
+      @see eoObject
+  */
+  string className() const {return "eo1dWDistance";};
+
+  //@}
+
+private:
+  ///Private ctor. Do not use
+  eo1dWDistance() {};
+
+  
+  eo1d<T,fitnessT>& innereo1d;
+};
+
+//@}
+
+
+#endif

eo/src/eoAltBreeder.h

@@ -0,0 +1,302 @@
+//-----------------------------------------------------------------------------
+// eoBreeder.h
+//-----------------------------------------------------------------------------
+
+#ifndef eoBreeder_h
+#define eoBreeder_h
+
+//-----------------------------------------------------------------------------
+
+#include <vector>          // vector
+#include <iterator>
+#include <eoUniform.h>     // eoUniform
+#include <eoOp.h>          // eoOp, eoMonOp, eoBinOp
+#include <eoPop.h>         // eoPop
+#include <eoPopOps.h>      // eoTransform
+#include <eoOpSelector.h>  // eoOpSelector
+#include <list>
+#include "eoRng.h"
+
+using namespace std;
+
+/*****************************************************************************
+ * eoBreeder: transforms a population using genetic operators.               *
+ * For every operator there is a rated to be applyed.                        *
+ *****************************************************************************/
+
+template<class EOT, class OutIt>
+class eoGeneralOp: public eoOp<EOT> 
+{
+public:
+
+  eoGeneralOp()
+    :eoOp<EOT>( Nary ) {};
+  virtual ~eoGeneralOp () {};
+
+  virtual void operator()( vector<const EOT*> _in, OutIt _out) const = 0;
+  virtual int nInputs(void) const = 0;
+  virtual int nOutputs(void) const = 0; // no support for 2 -> 2 xover
+
+   virtual string className() const {return "eoGeneralOp";};
+};
+
+template <class EOT, class OutIt>
+class eoWrappedMonOp : public eoGeneralOp<EOT, OutIt>
+{
+public :
+	eoWrappedMonOp(const eoMonOp<EOT>& _op) : eoGeneralOp<EOT, OutIt>(), op(_op) {}
+	virtual ~eoWrappedMonOp() {}
+
+  void operator()( vector<const EOT*> _in, OutIt _out) const
+  {
+		*_out = *_in[0];
+		op(*_out );
+  }
+  
+  int nInputs(void) const  { return 1; }
+  int nOutputs(void) const { return 1; }
+
+   virtual string className() const {return "eoWrappedOp";};
+
+
+private :
+	const eoMonOp<EOT>& op;
+};
+
+template <class EOT, class OutIt>
+class eoWrappedBinOp : public eoGeneralOp<EOT, OutIt>
+{
+public :
+	eoWrappedBinOp(const eoBinOp<EOT>& _op) : eoGeneralOp<EOT, OutIt>(), op(_op) {}
+	virtual ~eoWrappedBinOp() {}
+
+  void operator()( vector<const EOT*> _in, OutIt _out) const
+  {
+		*_out = *_in[0];
+		*(_out + 1) = *_in[1];
+		op(*_out, *(_out + 1));
+  }
+  
+  int nInputs(void) const  { return 2; }
+  int nOutputs(void) const { return 2; } // Yup, due to the bad design, can't choose between outputting 1 or 2 
+
+  virtual string className() const {return "eoWrappedOp";};
+
+
+private :
+	const eoBinOp<EOT>& op;
+};
+
+template <class EOT, class OutIt>
+class eoCombinedOp : public eoGeneralOp<EOT, OutIt>
+{
+public :
+
+	eoCombinedOp() : eoGeneralOp<EOT, OutIt>(), arity(0) {}
+	virtual ~eoCombinedOp() {}
+
+	int nInputs(void) const  { return arity; }
+	int nOutputs(void) const { return 1; } 
+
+	void addOp(eoGeneralOp<EOT, OutIt>* _op)
+	{
+		ops.push_back(_op);
+		arity = arity < _op->nInputs()? _op->nInputs() : arity;
+	}
+
+
+	void clear(void)
+	{
+		ops.resize(0);
+	}
+
+
+	void operator()( vector<const EOT*> _in, OutIt _out) const
+	{
+		for (int i = 0; i < ops.size(); ++i)
+		{
+			(*ops[i])(_in, _out);
+			_in[0] = &*_out;
+		}
+	}
+		
+private :
+	vector<eoGeneralOp<EOT, OutIt>* > ops;
+	int arity;
+};
+
+template<class EOT, class OutIt>
+class eoAltOpSelector: public eoOpSelector<EOT>, public vector<eoGeneralOp<EOT, OutIt>*>
+{
+public:
+  
+  virtual ID addOp( eoOp<EOT>& _op, float _arg )
+  {
+		eoGeneralOp<EOT, OutIt>* op = dynamic_cast<eoGeneralOp<EOT, OutIt>*>(&_op);
+
+		
+		if (op == 0)
+		{
+			switch(_op.readArity())
+			{
+			case unary :
+				oplist.push_back(auto_ptr<eoGeneralOp<EOT, OutIt> >(new eoWrappedMonOp<EOT, OutIt>(static_cast<eoMonOp<EOT>&>(_op))));
+
+				op = oplist.back().get();
+				break;
+			case binary :
+				oplist.push_back(auto_ptr<eoGeneralOp<EOT, OutIt> >(new eoWrappedBinOp<EOT, OutIt>(static_cast<eoBinOp<EOT>&>(_op))));
+				op = oplist.back().get();
+				break;
+			}
+		}
+
+	  iterator result = find(begin(), end(), (eoGeneralOp<EOT, OutIt>*) 0); // search for nullpointer
+	  
+	  if (result == end())
+	  {
+		  push_back(op);
+		  rates.push_back(_arg);
+		  return size();
+	  }
+	  // else
+	  
+		*result = op;
+		ID id = result - begin();
+		rates[id] = _arg;
+		return id;
+  }
+  
+  virtual const eoOp<EOT>& getOp( ID _id )
+  {
+	  return *operator[](_id);
+  }
+  
+  virtual void deleteOp( ID _id )
+  {
+	  operator[](_id) = 0; // TODO, check oplist and clear it there too.
+	  rates[_id] = 0.0;
+  }
+  
+  virtual eoOp<EOT>* Op()
+  {
+	  return &selectOp();
+  }
+
+
+  virtual eoGeneralOp<EOT, OutIt>& selectOp() = 0;
+
+
+  virtual string className() const { return "eoAltOpSelector"; };
+
+  void printOn(ostream& _os) const {}
+
+
+protected :
+
+	vector<float> rates;
+	list<auto_ptr<eoGeneralOp<EOT, OutIt> > > oplist;
+};
+
+template <class EOT, class OutIt> 
+class eoProportionalOpSelector : public eoAltOpSelector<EOT, OutIt>
+{
+	public :
+		eoProportionalOpSelector() : eoAltOpSelector<EOT, OutIt>() {}
+
+
+		virtual eoGeneralOp<EOT, OutIt>& selectOp()
+		{
+			int what = rng.roulette_wheel(rates);
+
+			return *operator[](what);
+		}
+};
+
+template <class EOT, class OutIt> 
+class eoSequentialOpSelector : public eoAltOpSelector<EOT, OutIt>
+{
+	public :
+		
+		eoSequentialOpSelector() : eoAltOpSelector<EOT, OutIt>() {}
+
+		virtual eoGeneralOp<EOT, OutIt>& selectOp()
+		{
+			for (int i = 0; i < size(); ++i)
+			{
+				if (operator[](i) == 0)
+					continue;
+
+				if (rng.flip(rates[i]))
+					combined.addOp(operator[](i));
+			}
+
+			return combined;
+		}		
+
+	private :
+
+	eoCombinedOp<EOT, OutIt> combined;
+};
+
+template <class EOT>
+class eoRandomIndy // living in a void right now
+{
+	public :
+
+		eoRandomIndy() {}
+
+	vector<const EOT*> operator()(int _n, eoPop<EOT>::iterator _begin, eoPop<EOT>::iterator _end)
+	{
+		vector<const EOT*> result(_n);
+
+		for (int i = 0; i < result.size(); ++i)
+		{
+			result[i] = &*(_begin + rng.random(_end - _begin));
+		}
+
+		return result;
+	}
+};
+
+template<class Chrom> class eoAltBreeder: public eoTransform<Chrom>
+{
+ public:
+	 typedef eoPop<Chrom>::reverse_iterator outIt;
+  /// Default constructor.
+  eoAltBreeder( eoAltOpSelector<Chrom, outIt>& _opSel): opSel( _opSel ) {}
+  
+  /// Destructor.
+  virtual ~eoAltBreeder() {}
+
+  /**
+   * Enlarges the population.
+   * @param pop The population to be transformed.
+   */
+  void operator()(eoPop<Chrom>& pop) 
+  {  
+	  int size = pop.size();
+
+      for (unsigned i = 0; i < size; i++) 
+	  {
+		eoGeneralOp<Chrom, outIt>& op = opSel.selectOp();
+
+		pop.resize(pop.size() + op.nOutputs());
+		vector<const Chrom*> indies = indySelector(op.nInputs(), pop.begin(), pop.begin() + size);
+		
+		op(indies, pop.rbegin());
+	  
+	  }
+	}
+  
+  /// The class name.
+  string classname() const { return "eoAltBreeder"; }
+  
+ private:
+  eoAltOpSelector<Chrom, outIt >& opSel;
+  eoRandomIndy<Chrom>    indySelector;
+};
+
+
+
+#endif eoBreeder_h

eo/src/eoAtomRandom.h

@@ -1,10 +1,10 @@
-// -*- mode: c++; c-indent-level: 4; c++-member-init-indent: 8; comment-column: 35; -*-
+/* -*- mode: c++; c-indent-level: 4; c++-member-init-indent: 8; comment-column: 35; -*-
+
+-----------------------------------------------------------------------------
+ eoAtomRandom.h
+   Increments or decrements by one a single element
+ (c) GeNeura Team, 1998
  
-//-----------------------------------------------------------------------------
-// eoAtomRandom.h
-//   Increments or decrements by one a single element
-// (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
@@ -22,10 +22,11 @@
     Contact: todos@geneura.ugr.es, http://geneura.ugr.es
  */
 //-----------------------------------------------------------------------------
-#ifndef _EOATOMCREEP_H
-#define _EOATOMCREEP_H
 
-#include <eoRandom.h>
+#ifndef _EOATOMRANDOM_H
+#define _EOATOMRANDOM_H
+
+#include <eoRnd.h>
 
 /** Modifies using a random number generator, that is entered in the ctor.
     The RNG must return positive or negative numbers, whatever.
@@ -35,12 +36,12 @@ class eoAtomRandom: public eoAtomMutator<T> {
 public:
 
   /// 
-  eoAtomRandom( eoRandom& _rng): rng( _rng ) {};
+  eoAtomRandom( eoRnd<T>& _rng): rng( _rng ) {};
   
   ///
   virtual ~eoAtomRandom() {};
   
-  ///
+  /// Adds the value generated by the RNG to the former value
   virtual void operator()( T& _val ) const {
     _val += rng();
   }
@@ -55,7 +56,7 @@ public:
   //@}
 
 private:
-  eoRandom rng;
+  eoRnd<T>& rng;
 
 };
 

eo/src/eoData.h

@@ -1,6 +1,28 @@
-//-----------------------------------------------------------------------------
+/** -*- mode: c++; c-indent-level: 4; c++-member-init-indent: 8; comment-column: 35; -*-
-// eoData.h
+
-//-----------------------------------------------------------------------------
+-----------------------------------------------------------------------------
+    eoData.h
+        Some numeric limits and types and things like that; with #ifdefs to keep
+	compatibility
+
+    (c) GeNeura Team & Maarten Keijzer, 1998, 1999, 2000
+
+    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 EODATA_H
 #define EODATA_H
@@ -23,7 +45,9 @@ using namespace std;
 #else	
         #include <float.h>
         #include <limits.h>
+#ifndef _WIN32    // should be the define for UN*X flavours: _POSIX??
         #include <values.h>
+#endif
 	#ifndef MAXFLOAT
 		#define  MAXFLOAT (float)1e127
 		#define  MAXDOUBLE  (double)1.79769313486231570e+308

eo/src/eoDistance.h

@@ -0,0 +1,63 @@
+/* -*- mode: c++; c-indent-level: 4; c++-member-init-indent: 8; comment-column: 35; -*-
+
+    -----------------------------------------------------------------------------
+    eoObject.h
+      This is the base class for most objects in EO. It basically defines an interf
+    face for giving names to classes.
+
+    (c) GeNeura Team, 1998, 1999, 2000
+ 
+    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 EODISTANCE_H
+#define EODISTANCE_H
+
+//-----------------------------------------------------------------------------
+
+using namespace std;
+
+//-----------------------------------------------------------------------------
+// eoDistance
+//-----------------------------------------------------------------------------
+/** Defines an interface for measuring distances between evolving objects */
+template <class EOT>
+class eoDistance {
+ public:
+  
+  /// Default Constructor.
+  eoDistance() {}
+
+  /// Copy constructor.
+  eoDistance( const eoDistance& ) {}
+
+  /// Virtual dtor. They are needed in virtual class hierarchies.
+  virtual ~eoDistance() {}
+  
+
+  /** Return the distance from the object with this interface to other
+      object of the same type.
+  */
+  virtual double distance( const EOT& ) const = 0;
+
+  /// Returns classname
+  virtual string className() const { return "eoDistance"; }
+
+};
+
+#endif EOOBJECT_H

eo/src/eoEasyEA.h

@@ -57,7 +57,7 @@ template<class Chrom> class eoEasyEA: public eoAlgo<Chrom>
   
   /// Apply one generation of evolution to the population.
   virtual void operator()(eoPop<Chrom>& pop) {
-    while ( terminator( pop ) ){
+    do {
       try
 	{
 	  step(pop);
@@ -68,7 +68,7 @@ template<class Chrom> class eoEasyEA: public eoAlgo<Chrom>
 	  s.append( " in eoEasyEA ");
 	  throw runtime_error( s );
 	}
-    } 
+    } while ( terminator( pop ) );
   }
   
   /// Class name.

eo/src/eoEvalFuncPtr.h

@@ -1,9 +1,12 @@
-// -*- mode: c++; c-indent-level: 4; c++-member-init-indent: 8; comment-column: 35; -*-
+/** -*- mode: c++; c-indent-level: 4; c++-member-init-indent: 8; comment-column: 35; -*-
+
+-----------------------------------------------------------------------------
+    eoEvalFuncPtr.h
+      Converts a classical C fitness evaluation function into a fitness
+      evaluation object
+
+    (c) GeNeura Team, 2000
  
-//-----------------------------------------------------------------------------
-// eoOp.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
@@ -35,16 +38,22 @@
 template< class EOT >
 struct eoEvalFuncPtr: public eoEvalFunc<EOT> {
 
-  eoEvalFuncPtr( void (* _eval)( EOT& ) )
+  /** Applies the function to the chromosome and sets the fitness of the
+      Chrom. Thus, the evaluation function need not be worried about that.
+      @param _eval pointer to the evaluation function, takes a EOT as an
+                   argument and returns the fitness
+      @return the evaluated fitness for that object.
+  */
+  eoEvalFuncPtr( EOFitT (* _eval)( const EOT& ) )
     : eoEvalFunc<EOT>(), evalFunc( _eval ) {};
   
   /// Effectively applies the evaluation function to an EO 
   virtual void operator() ( EOT & _eo ) const {
-      (*evalFunc)( _eo );
+    _eo.fitness((*evalFunc)( _eo ));
   };
     
   private:
-   void (* evalFunc )( EOT& );
+    EOFitT (* evalFunc )( EOT& );
 };
 
 #endif

eo/src/eoEvalFuncPtrCnt.h

@@ -0,0 +1,62 @@
+/** -*- mode: c++; c-indent-level: 4; c++-member-init-indent: 8; comment-column: 35; -*-
+
+-----------------------------------------------------------------------------
+    eoEvalFuncPtrCnt.h
+      Same as eoEvalFuncPtr, but counts the number of evaluations
+
+    (c) GeNeura Team, 2000
+ 
+    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 EOEVALFUNCPTRCNT_H
+#define EOEVALFUNCPTRCNT_H
+
+#include <eoEvalFuncPtr.h>
+
+/** EOEvalFuncCntPtr: This class
+ * takes an existing function pointer and converts it into a evaluation
+ * function class. That way, old style C or C++ functions can be adapted to EO
+ * function classes.
+ */
+template< class EOT >
+struct eoEvalFuncPtrCnt: public eoEvalFuncPtr<EOT> {
+
+  /** Applies the function to the chromosome and sets the fitness of the
+      Chrom. Thus, the evaluation function need not be worried about that.
+      @param _eval pointer to the evaluation function, takes a EOT as an
+                   argument and returns the fitness
+      @return the evaluated fitness for that object.
+  */
+  eoEvalFuncPtrCnt( EOFitT (* _eval)( const EOT& ) )
+    : eoEvalFuncPtr<EOT>( _eval ), numOfEvaluations( 0 )  {};
+  
+  /// Effectively applies the evaluation function to an EO 
+  virtual void operator() ( EOT & _eo ) const {
+     eoEvalFuncPtr<EOT>::operator()( _eo );
+    numOfEvaluations++;
+  };
+
+  ///
+  unsigned getNumOfEvaluations() const { return numOfEvaluations; };
+  
+private:
+  mutable unsigned numOfEvaluations;
+};
+
+#endif

eo/src/eoGOpSelector.h

@@ -0,0 +1,139 @@
+/** -*- mode: c++; c-indent-level: 4; c++-member-init-indent: 8; comment-column: 35; -*-
+
+    -----------------------------------------------------------------------------
+    eoGOpSelector.h
+      Base class for generalized (n-inputs, n-outputs) operator selectors.
+      Includes code and variables that contain operators and rates
+
+    (c) Maarten Keijzer, GeNeura Team 1998, 1999, 2000
+ 
+    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 eoGOpSelector_h
+#define eoGOpSelector_h
+
+//-----------------------------------------------------------------------------
+
+#include <vector>          // vector
+#include <iterator>
+#include <eoUniform.h>     // eoUniform
+#include <eoGeneralOp.h>          // eoOp, eoMonOp, eoBinOp
+#include <eoPop.h>         // eoPop
+#include <eoPopOps.h>      // eoTransform
+#include <eoOpSelector.h>  // eoOpSelector
+#include <list>
+#include "eoRNG.h"
+
+using namespace std;
+
+/** Base class for alternative selectors, which use the generalized operator
+    interface */
+
+template<class EOT>
+class eoGOpSelector: public eoOpSelector<EOT>, public vector<eoGeneralOp<EOT>*>
+{
+public:
+
+  /// Dtor
+  virtual ~eoGOpSelector() {
+    for ( list< eoGeneralOp<EOT>* >::iterator i= ownOpList.begin();
+	  i != ownOpList.begin(); i ++ ) {
+      delete *i;
+    }
+  }
+  
+  /// Add any kind of operator to the operator mix, with an argument
+  virtual ID addOp( eoOp<EOT>& _op, float _arg ) {
+    eoGeneralOp<EOT>* op = dynamic_cast<eoGeneralOp<EOT>*>(&_op);
+
+    // if it's not a general op, it's a "old" op; create a wrapped op from it
+    // and keep it on a list to delete them afterwards
+    // will use auto_ptr when they're readily available
+    if (op == 0) {
+	switch(_op.readArity())
+	  {
+	  case unary :
+	    op=  new eoWrappedMonOp<EOT>(static_cast<eoMonOp<EOT>&>(_op));
+	    break;
+	  case binary :
+	    op =  new eoWrappedBinOp<EOT>(static_cast<eoBinOp<EOT>&>(_op));
+	    break;
+	  }
+	ownOpList.push_back( op );
+      }
+
+    iterator result = find(begin(), end(), (eoGeneralOp<EOT>*) 0); // search for nullpointer
+	  
+    if (result == end())
+      {
+	push_back(op);
+	rates.push_back(_arg);
+	return size();
+      }
+    // else
+    
+    *result = op;
+    ID id = result - begin();
+    rates[id] = _arg;
+    return id;
+  }
+  
+  /** Retrieve the operator using its integer handle
+      @param _id The id number. Should be a valid id, or an exception 
+                 will be thrown
+      @return a reference of the operator corresponding to that id.
+  */
+  virtual const eoOp<EOT>& getOp( ID _id )
+  {
+	  return *operator[](_id);
+  }
+  
+  ///
+  virtual void deleteOp( ID _id )
+  {
+	  operator[](_id) = 0; // TODO, check oplist and clear it there too.
+	  rates[_id] = 0.0;
+  }
+  
+  ///
+  virtual eoOp<EOT>* Op()
+  {
+	  return &selectOp();
+  }
+
+  ///
+  virtual eoGeneralOp<EOT>& selectOp() = 0;
+
+  ///
+  virtual string className() const { return "eoGOpSelector"; };
+
+  ///
+  void printOn(ostream& _os) const {
+    _os << className() << endl; 
+    for ( unsigned i=0; i!= rates.size(); i++ ) {
+      _os << *(operator[](i))  << "\t" << rates[i] << endl;
+    }
+  }
+
+
+protected :
+  vector<float> rates;
+  list< eoGeneralOp<EOT>* > ownOpList;
+};
+
+#endif eoGOpSelector_h

eo/src/eoGeneralOp.h

@@ -0,0 +1,200 @@
+/* -*- mode: c++; c-indent-level: 4; c++-member-init-indent: 8; comment-column: 35; -*-
+
+  -----------------------------------------------------------------------------
+  eoGeneralOp.h
+    General genetic operator, which can be used to wrap any unary or binary
+    operator
+ (c) Maarten Keijzer (mak@dhi.dk) and GeNeura Team, 1999, 2000
+ 
+    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 eoGeneralOp_h
+#define eoGeneralOp_h
+
+//-----------------------------------------------------------------------------
+
+#include <vector>          // vector
+#include <iterator>
+#include <eoUniform.h>     // eoUniform
+#include <eoOp.h>          // eoOp, eoMonOp, eoBinOp
+#include <eoPop.h>         // eoPop
+#include <eoPopOps.h>      // eoTransform
+#include <eoOpSelector.h>  // eoOpSelector
+#include <list>
+#include "eoRNG.h"
+
+using namespace std;
+
+/**
+ * eGeneralOp: General genetic operator; for objects used to transform sets
+ of EOs
+*/
+template<class EOT>
+class eoGeneralOp: public eoOp<EOT>
+{
+public:
+
+  /// Ctor that honors its superclass
+  eoGeneralOp(): eoOp<EOT>( Nary ) {};
+
+  /// Virtual dtor
+  virtual ~eoGeneralOp () {};
+
+  /** Method that really does the stuff. Applies the genetic operator
+      to a vector of inputs, and puts results in the output vector */
+  virtual void operator()( eoPop<EOT>::iterator _in, 
+			   insert_iterator< eoPop<EOT> > _out) const = 0;
+
+  /// Number of inputs
+  virtual unsigned nInputs(void) const { return repNInputs;};
+
+  /// Number of output arguments, or arguments that are pushed onto the output vector
+  virtual unsigned nOutputs(void) const { return repNOutputs; }; 
+  
+  virtual string className() const {return "eoGeneralOp";};
+
+protected:
+  /// Default ctor; protected so that only derived classes can use it
+  eoGeneralOp( unsigned _nInputs = 0, unsigned _nOutputs = 0 )
+    : repNInputs( _nInputs), repNOutputs( _nOutputs) {};
+
+  /// change number of inputs
+  void setNInputs( unsigned _nInputs) { repNInputs = _nInputs;};
+  
+  /// change number of outputs
+  void setNOutputs( unsigned _nOutputs) { repNOutputs = _nOutputs;};
+
+private:
+  unsigned repNInputs;
+  unsigned repNOutputs;
+};
+
+
+/// Wraps monary operators
+template <class EOT>
+class eoWrappedMonOp : public eoGeneralOp<EOT>
+{
+public :
+  ///
+  eoWrappedMonOp(const eoMonOp<EOT>& _op) : eoGeneralOp<EOT>( 1, 1), op(_op) {};
+
+  ///
+  virtual ~eoWrappedMonOp() {}
+
+  /// Instantiates the abstract method
+  void operator()( eoPop<EOT>::iterator _in, 
+		   insert_iterator< eoPop< EOT> > _out ) const {
+    EOT result = *_in;
+    op( result );
+    *_out = result;
+  }
+  
+  ///
+  virtual string className() const {return "eoWrappedMonOp";};
+
+
+private :
+  const eoMonOp<EOT>& op;
+};
+
+
+/// Wraps binary operators
+template <class EOT>
+class eoWrappedBinOp : public eoGeneralOp<EOT>
+{
+public :
+  ///
+  eoWrappedBinOp(const eoBinOp<EOT>& _op) : eoGeneralOp<EOT>(2, 2), op(_op) {}
+
+  ///
+  virtual ~eoWrappedBinOp() {}
+
+  /// Instantiates the abstract method. EOT should have copy ctor.
+  void operator()(eoPop<EOT>::iterator _in, 
+		  insert_iterator< eoPop< EOT> > _out  ) const {
+    EOT out1 = *_in;
+    _in++;
+    EOT out2 = *_in;
+    op(out1, out2);
+    *_out++ = out1;
+    *_out = out2;
+  }
+  
+  ///
+  virtual string className() const {return "eoWrappedBinOp";};
+
+private :
+	const eoBinOp<EOT>& op;
+};
+
+/// Combines several ops
+template <class EOT>
+class eoCombinedOp : public eoGeneralOp<EOT>
+{
+public :
+  
+  ///
+  eoCombinedOp() : eoGeneralOp<EOT>() {}
+
+  ///
+  virtual ~eoCombinedOp() {}
+ 
+  /// Adds a new operator to the combined Op
+  void addOp(eoGeneralOp<EOT>* _op) {
+    ops.push_back(_op);
+    unsigned nInputs = nInputs() < _op->nInputs()? _op->nInputs() : nInputs;
+    setNInputs( nInputs );
+    unsigned nOutputs = nOutputs() < _op->nOutputs()? _op->nOutputs() : nOutputs;
+    setNOutputs( nInputs );
+  }
+
+
+  /// Erases all operators added so far
+  void clear(void) {
+    ops.resize(0);
+  }
+
+
+  /// Applies all ops in the combined op
+  void operator()( eoPop<EOT>::iterator _in, 
+		   insert_iterator< eoPop< EOT> > _out ) const {
+    // used for provisional input and output. Results are put in provOut,
+    // and copied back to provIn.
+    eoPop<EOT> provIn, provOut;
+    insert_iterator< eoPop< EOT> > out = provOut.begin();
+    ops[0]( _in, out );
+    for ( unsigned i = 1; i < ops.size; i ++ ) {
+      copy( provOut.begin(), provOut.end(), provIn.begin() );
+      insert_iterator< eoPop< EOT> > in = provIn.begin();
+      out = provOut.begin();
+      ops[i]( in, out );
+    }
+
+    // Copy back to output
+    copy( provOut.begin(), provOut.end(), _out );
+      
+    
+  }
+		
+private :
+  vector<eoGeneralOp<EOT>* > ops;
+};
+
+#endif eoGeneral_h

eo/src/eoLottery.h

@@ -3,7 +3,7 @@
 //-----------------------------------------------------------------------------
 // eoLottery.h
 //   Implements the lottery procedure for selection
-// (c) GeNeura Team, 1998
+// (c) GeNeura Team, 1998 - Marc Schoenauer, 2000
 /* 
     This library is free software; you can redistribute it and/or
     modify it under the terms of the GNU Lesser General Public
@@ -33,52 +33,48 @@
 #include <eo>          // eoPop eoSelect MINFLOAT
 
 //-----------------------------------------------------------------------------
-/// eoLottery: a selection method.
+/** eoLottery: a selection method. Puts into the output a group of individuals 
-/// requires Chrom::Fitness to be float castable
+    selected using lottery; individuals with higher probability will have more
+    chances of being selected.
+    Requires EOT::Fitness to be float castable
+*/
 //-----------------------------------------------------------------------------
 
-template<class Chrom> class eoLottery: public eoBinPopOp<Chrom>
+template<class EOT> class eoLottery: public eoBinPopOp<EOT>
 {
  public:
   /// (Default) Constructor.
   eoLottery(const float& _rate = 1.0): rate(_rate) {}
   
-  /// 
+  /** actually selects individuals from pop and pushes them back them into breeders
-  void operator()( eoPop<Chrom>& pop, eoPop<Chrom>& breeders) 
+   *  until breeders has the right size: rate*pop.size()
+   *  BUT what happens if breeders is already too big?
+   * Too big for what?
+   */
+  void operator()( eoPop<EOT>& pop, eoPop<EOT>& breeders) 
     {
       // scores of chromosomes
       vector<float> score(pop.size());
 
-      // calculates accumulated scores for chromosomes
+      // calculates total scores for chromosomes
-      for (unsigned i = 0; i < pop.size(); i++)
+      float total = 0;
+      for (unsigned i = 0; i < pop.size(); i++) {
 	score[i] = static_cast<float>(pop[i].fitness()); 
+	total += score[i];
+      }
 
-      float sum = accumulate(score.begin(), score.end(), MINFLOAT);
+      // number of offspring needed
-      transform(score.begin(), score.end(), score.begin(), 
+      int target = (int)rint(rate * pop.size());
-		bind2nd(divides<float>(), sum));
-      partial_sum(score.begin(), score.end(), score.begin());
 
-      // generates random numbers
+      // test of consistency
-      vector<float> random(rint(rate * pop.size()));
+      if (breeders.size() >= target) {
-      generate(random.begin(), random.end(), eoUniform<float>(0,1));
+	  throw("Problem in eoLottery: already too many offspring");
-      sort(random.begin(), random.end(), less<float>());
+      }
 
       // selection of chromosomes
-      unsigned score_index = 0;   // position in score vector
+      while (breeders.size() < target) {
-      unsigned random_index = 0;  // position in random vector
+	  unsigned indloc = rng.roulette_wheel(score, total);
-      while (breeders.size() < random.size()) 
+	  breeders.push_back(pop[indloc]);
-	{
-	  if(random[random_index] < score[score_index]) 
-	    {
-	      breeders.push_back(pop[score_index]);
-	      random_index++;
-	    }
-	  else
-	    if (score_index < pop.size())
-	      score_index++;
-	    else
-	      fill_n(back_insert_iterator<eoPop<Chrom> >(breeders), 
-		     random.size() - breeders.size(), pop.back());
       }
     }
   

eo/src/eoNegExp.h

@@ -1,9 +1,9 @@
-// -*- mode: c++; c-indent-level: 4; c++-member-init-indent: 8; comment-column: 35; -*-
+/** -*- mode: c++; c-indent-level: 4; c++-member-init-indent: 8; comment-column: 35; -*-
+
+-----------------------------------------------------------------------------
+ eoNegExp.h
+ (c) GeNeura Team, 1998
  
-//-----------------------------------------------------------------------------
-// eoNegExp.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
@@ -43,7 +43,7 @@ class eoNegExp: public eoRnd<T>
  public:
   /**
    * Default constructor.
-   * @param _mean  Dsitribution mean
+   * @param _mean  Distribution mean
    */
   eoNegExp(T _mean): eoRnd<T>(), mean(_mean) {};
 

eo/src/eoObject.h

@@ -1,9 +1,12 @@
-// -*- mode: c++; c-indent-level: 4; c++-member-init-indent: 8; comment-column: 35; -*-
+/** -*- mode: c++; c-indent-level: 4; c++-member-init-indent: 8; comment-column: 35; -*-
+
+    -----------------------------------------------------------------------------
+    eoObject.h
+      This is the base class for most objects in EO. It basically defines an interf
+    face for giving names to classes.
+
+    (c) GeNeura Team, 1998, 1999, 2000
  
-//-----------------------------------------------------------------------------
-// eoObject.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

eo/src/eoOp.h

@@ -87,7 +87,6 @@ public:
   virtual string className() const {return "eoOp";};
   //@}
 
-
 private:
   /// arity is the number of operands it takes
   Arity arity;

eo/src/eoOpSelector.h

@@ -1,9 +1,12 @@
-// -*- mode: c++; c-indent-level: 4; c++-member-init-indent: 8; comment-column: 35; -*-
+/* -*- mode: c++; c-indent-level: 4; c++-member-init-indent: 8; comment-column: 35; -*-
+
+    -----------------------------------------------------------------------------
+    eoOpSelector.h
+      Base class for operator selectors, which return 1 operator according
+      to some criterium
+
+    (c) GeNeura Team 1998, 1999, 2000
  
-//-----------------------------------------------------------------------------
-// eoOpSelector.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
@@ -20,6 +23,7 @@
 
     Contact: todos@geneura.ugr.es, http://geneura.ugr.es
 */
+
 //-----------------------------------------------------------------------------
 
 #ifndef EOOPSELECTOR_H
@@ -34,7 +38,7 @@
 #include <eoOp.h>
 
 //-----------------------------------------------------------------------------
-/** An operator selector is an object that contains a set of EO operators, and 
+/** An operator selector is an object that contains a set of EO operators,
 and selects one based on whatever criteria. It will be used in the breeder objects.\\
 This class is basically a generic interface for operator selection
 */
@@ -42,6 +46,7 @@ template<class EOT>
 class eoOpSelector: public eoObject, public eoPrintable
 {
 public:
+  /// type of IDs assigned to each operators, used to handle them
   typedef unsigned ID;
   
   /** add an operator to the operator set
@@ -55,7 +60,7 @@ public:
       modified or whatever 
       @param _id  a previously assigned ID
       @throw runtime_exception if the ID does not exist*/
-  virtual eoOp<EOT>& getOp( ID _id ) = 0;
+  virtual const eoOp<EOT>& getOp( ID _id ) = 0;
   
   /** Remove an operator from the operator set
       @param _id a previously assigned ID

eo/src/eoPop.h

@@ -49,16 +49,12 @@ to the population.
 template<class EOT>
 class eoPop: public vector<EOT>, public eoObject, public eoPersistent {
 
-  /*
-   Victor Rivas (vrivas@ujaen.es): 15-Dec-1999
-   An EO can have NO genes.
 /// Type is the type of each gene in the chromosome
 #ifdef _MSC_VER
 	typedef EOT::Type Type;
 #else
 	typedef typename EOT::Type Type;
 #endif
-  */
 
  public:
 	/** Protected ctor. This is intended to avoid creation of void populations, except 
@@ -72,9 +68,6 @@ public:
 	@param _eoSize chromosome size. EOT should accept a fixed-size ctor
 	@param _geneRdn random number generator for each of the genes
 	*/
-  /*
-    Victor Rivas (vrivas@ujaen.es): 15-Dec-1999
-    This constructor must be substitued by one using factories.
 	eoPop( unsigned _popSize, unsigned _eoSize, eoRnd<Type> & _geneRnd )
 	  :vector<EOT>() {
 	  for ( unsigned i = 0; i < _popSize; i ++ ){
@@ -82,16 +75,12 @@ public:
 	    push_back( tmpEOT );
 	  }
 	};
-  */
 	
 	/** Ctor for variable-size chromosomes, with variable content
 	    @param _popSize total population size
 	    @param _sizeRnd RNG for the chromosome size. This will be added 1, just in case.
 	    @param _geneRdn random number generator for each of the genes
 	*/
-  /*
-    Victor Rivas (vrivas@ujaen.es): 15-Dec-1999
-    This constructor must be substitued by one using factories.
 	eoPop( unsigned _popSize, eoRnd<unsigned> & _sizeRnd, eoRnd<Type> & _geneRnd )
 	  :vector<EOT>() {
 	  for ( unsigned i = 0; i < _popSize; i ++ ){
@@ -100,7 +89,7 @@ public:
 	    push_back( tmpEOT );
 	  }
 	};
-  */
+
 	/** Ctor from an istream; reads the population from a stream,
 	    each element should be in different lines
 	    @param _is the stream