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 
+  /// Effectively applies the evaluation function to an EO 
-    virtual void operator() ( EOT & _eo ) const {
+  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/eoGeneration.h

@@ -71,9 +71,9 @@ template<class Chrom> class eoGeneration: public eoAlgo<Chrom>
   string className() const { return "eoGeneration"; }
   
  private:
-  eoBinPopOp<Chrom>&    select;
+  eoBinPopOp<Chrom>& select;
   eoMonPopOp<Chrom>& transform;
-  eoBinPopOp<Chrom>&     replace;
+  eoBinPopOp<Chrom>& replace;
   eoEvalFunc<Chrom>& evaluator;
 };
 

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,53 +33,49 @@
 #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());
-	}
     }
   
  private:

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
@@ -19,7 +22,7 @@
     Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
 
     Contact: todos@geneura.ugr.es, http://geneura.ugr.es
- */
+*/
 //-----------------------------------------------------------------------------
 
 #ifndef EOOBJECT_H

eo/src/eoOp.h

@@ -77,16 +77,15 @@ public:
    * @param _os A ostream.
    */
   virtual void printOn(ostream& _os) const {
-	  _os << className(); 
+    _os << className(); 
-//	  _os << arity;
+    //	  _os << arity;
   };
   
-	/** Inherited from eoObject 
+  /** Inherited from eoObject 
-		  @see eoObject
+      @see eoObject
-	*/
+  */
-	virtual string className() const {return "eoOp";};
+  virtual string className() const {return "eoOp";};
-    //@}
+  //@}
-
 
 private:
   /// arity is the number of operands it takes

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
@@ -19,7 +22,8 @@
     Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
 
     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,87 +49,76 @@ to the population.
 template<class EOT>
 class eoPop: public vector<EOT>, public eoObject, public eoPersistent {
 
-  /*
+/// Type is the type of each gene in the chromosome
-   Victor Rivas (vrivas@ujaen.es): 15-Dec-1999
+#ifdef _MSC_VER
-   An EO can have NO genes.
+	typedef EOT::Type Type;
-   /// Type is the type of each gene in the chromosome
+#else
-   #ifdef _MSC_VER
+	typedef typename EOT::Type Type;
-   typedef EOT::Type Type;
+#endif
-   #else
-   typedef typename EOT::Type Type;
-   #endif
-  */
 
-public:
+ public:
-  /** Protected ctor. This is intended to avoid creation of void populations, except 
+	/** Protected ctor. This is intended to avoid creation of void populations, except 
-      from sibling classes
+	    from sibling classes
-  */
+	*/
-  eoPop():vector<EOT>() {};
+	eoPop()	  :vector<EOT>() {};
 	
 	
-  /** Ctor for fixed-size chromosomes, with variable content
+	 /** Ctor for fixed-size chromosomes, with variable content
-      @param _popSize total population size
+	@param _popSize total population size
-      @param _eoSize chromosome size. EOT should accept a fixed-size ctor
+	@param _eoSize chromosome size. EOT should accept a fixed-size ctor
-      @param _geneRdn random number generator for each of the genes
+	@param _geneRdn random number generator for each of the genes
-  */
+	*/
-  /*
+	eoPop( unsigned _popSize, unsigned _eoSize, eoRnd<Type> & _geneRnd )
-    Victor Rivas (vrivas@ujaen.es): 15-Dec-1999
+	  :vector<EOT>() {
-    This constructor must be substitued by one using factories.
+	  for ( unsigned i = 0; i < _popSize; i ++ ){
-  eoPop( unsigned _popSize, unsigned _eoSize, eoRnd<Type> & _geneRnd )
+	    EOT tmpEOT( _eoSize, _geneRnd);
-    :vector<EOT>() {
+	    push_back( tmpEOT );
-    for ( unsigned i = 0; i < _popSize; i ++ ){
+	  }
-      EOT tmpEOT( _eoSize, _geneRnd);
+	};
-      push_back( tmpEOT );
-    }
-  };
-  */
 	
-  /** Ctor for variable-size chromosomes, with variable content
+	/** Ctor for variable-size chromosomes, with variable content
-      @param _popSize total population size
+	    @param _popSize total population size
-      @param _sizeRnd RNG for the chromosome size. This will be added 1, just in case.
+	    @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
+	    @param _geneRdn random number generator for each of the genes
-  */
+	*/
-  /*
+	eoPop( unsigned _popSize, eoRnd<unsigned> & _sizeRnd, eoRnd<Type> & _geneRnd )
-    Victor Rivas (vrivas@ujaen.es): 15-Dec-1999
+	  :vector<EOT>() {
-    This constructor must be substitued by one using factories.
+	  for ( unsigned i = 0; i < _popSize; i ++ ){
-    eoPop( unsigned _popSize, eoRnd<unsigned> & _sizeRnd, eoRnd<Type> & _geneRnd )
+	    unsigned size = 1 + _sizeRnd();
-    :vector<EOT>() {
+	    EOT tmpEOT( size, _geneRnd);
-    for ( unsigned i = 0; i < _popSize; i ++ ){
+	    push_back( tmpEOT );
-    unsigned size = 1 + _sizeRnd();
+	  }
-    EOT tmpEOT( size, _geneRnd);
+	};
-    push_back( tmpEOT );
-    }
-    };
-  */
-  /** Ctor from an istream; reads the population from a stream,
-      each element should be in different lines
-      @param _is the stream
-  */
-  eoPop( istream& _is ):vector<EOT>() {
-    readFrom( _is );
-  }
 
-  ///
+	/** Ctor from an istream; reads the population from a stream,
-  ~eoPop() {};
+	    each element should be in different lines
+	    @param _is the stream
+	*/
+	eoPop( istream& _is ):vector<EOT>() {
+	  readFrom( _is );
+	}
 	
-  /** @name Methods from eoObject	*/
+	///
-  //@{
+	~eoPop() {};
-  /**
-   * Read object. The EOT class must have a ctor from a stream;
-   in this case, a strstream is used.
-   * @param _is A istream.
 
-   */
+  	/** @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) {
     while( _is ) {  // reads line by line, and creates an object per
       // line
       char line[MAXLINELENGTH];
       _is.getline( line, MAXLINELENGTH-1 );
-      if (strlen( line ) ) {
+	  if (strlen( line ) ) {
-	istrstream s( line );
+		istrstream s( line );
-	EOT thisEOT( s );
+		EOT thisEOT( s );
-	push_back( thisEOT );      
+		push_back( thisEOT );      
-      }
+	  }
     }
   }
   
@@ -138,7 +127,7 @@ public:
    * @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 {
     copy( begin(), end(), ostream_iterator<EOT>( _os, "\n") );
   };
@@ -147,9 +136,9 @@ public:
       @see eoObject
   */
   virtual string className() const {return "eoPop";};
-  //@}
+    //@}
 
-protected:
+ protected:
 
 };
 #endif

eo/src/eoPopOps.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; -*-
+
+   -----------------------------------------------------------------------------
+   eoPopOps.h 
+   (c) GeNeura Team, 1998
  
-//-----------------------------------------------------------------------------
-// eoPopOps.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
@@ -108,7 +108,8 @@ class eoBinPopOp: public eoObject{
 
 //-----------------------------------------------------------------------------
 
-/** eoSelect usually takes elements from one population, with or without transformation, and transfers them to the other population */
+/** eoSelectone selects only one element from a whole population. Usually used to 
+    select mates*/
 template<class EOT>
 class eoSelectOne: public eoObject{
 

eo/src/eoProportionalGOpSel.h

@@ -0,0 +1,51 @@
+/** -*- mode: c++; c-indent-level: 4; c++-member-init-indent: 8; comment-column: 35; -*-
+
+    -----------------------------------------------------------------------------
+    eoProportionalGOpSel.h
+      Proportional operator selector, selects operators proportionally to its rate
+
+    (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 eoProportionalGOpSel_h
+#define eoProportionalGOpSel_h
+
+//-----------------------------------------------------------------------------
+
+#include <eoGOpSelector.h>  // eoOpSelector
+
+template <class EOT> 
+class eoProportionalGOpSel : public eoGOpSelector<EOT>
+{
+public :
+  eoProportionalGOpSel() : eoGOpSelector<EOT>() {}
+  
+  /** Returns the operator proportionally selected */
+  virtual eoGeneralOp<EOT>& selectOp()
+    {
+      unsigned what = rng.roulette_wheel(rates);
+      return *operator[](what);
+    }
+
+   ///
+  virtual string className() const { return "eoGOpSelector"; };
+
+};
+
+#endif eoProportionalGOpSel_h

eo/src/eoRNG.h

@@ -113,7 +113,7 @@ public :
      @see reseed
   */
 
-  eoRng(uint32 s = (uint32) time(0) ) : state(0), next(0), left(-1), cached(false), N(624), M(397), K((0x9908B0DFU))  {
+  eoRng(uint32 s = (uint32) time(0) ) : state(0), next(0), left(-1), cached(false), N(624), M(397), K(0x9908B0DFU)  {
     state = new uint32[N+1];
     initialize(s);
   } 
@@ -197,7 +197,7 @@ public :
    {
      if (total == 0)
        { // count 
-	 for (unsigned i = 0; i < vec.size(); ++i)
+	 for (int i = 0; i < vec.size(); ++i)
 	   total += vec[i];
        }
      

eo/src/eoRnd.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; -*-
+
+-----------------------------------------------------------------------------
+ eoRnd.h
+ (c) GeNeura Team, 1998
  
-//-----------------------------------------------------------------------------
-// eoRnd.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/eoString.h

@@ -61,6 +61,14 @@ public:
 		}
 	};
 
+  	/** Ctor from a stream
+	@param _s input stream
+	*/
+	eoString( istream & _s )
+	  : eo1d<char, fitnessT>(){ 
+	  _s >> *this;
+	};
+
 	/// copy ctor
 	eoString( const eoString<fitnessT>& _eoStr )
 		:eo1d<char, fitnessT>( static_cast<const eo1d<char, fitnessT> & > ( _eoStr ) ), 

eo/src/eoUniform.h

@@ -1,10 +1,10 @@
-// eoUniform.h
+/* -*- 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; -*-
+
+  -----------------------------------------------------------------------------
+  eoUniform.h
+    Uniform random number generator; 
+  (c) GeNeura Team, 1998
  
-//-----------------------------------------------------------------------------
-// EOUniform.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,7 +20,7 @@
     Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
 
     Contact: todos@geneura.ugr.es, http://geneura.ugr.es
- */
+*/
 //-----------------------------------------------------------------------------
 
 #ifndef _EOUNIFORM_H

eo/src/eoVector.h

@@ -1,9 +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; -*-
+
+   -----------------------------------------------------------------------------
+   eoVector.h
+       Turns an STL vector into an EO
+   (c) GeNeura Team, 1998
  
-//-----------------------------------------------------------------------------
-// eoVector.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
@@ -19,9 +20,9 @@
     Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
 
     Contact: todos@geneura.ugr.es, http://geneura.ugr.es
- */
+*/
-//-----------------------------------------------------------------------------
 
+//-----------------------------------------------------------------------------
 
 #ifndef _eoVector_H
 #define _eoVector_H
@@ -38,7 +39,7 @@
  with the same gene type as the type with which
  the vector has been instantiated
 */
-template <class T, class fitnessT>
+template <class T, class fitnessT=float>
 class eoVector: public eo1d<T, fitnessT>, public vector<T> {
 public:
   typedef T Type ;

eo/test/Makefile.am

@@ -17,7 +17,36 @@ LDADDS = $(top_builddir)/src/libeo.a
 noinst_PROGRAMS = t-eobreeder t-eoinclusion t-eoinsertion t-eo t-eofitness \
 	t-eoproblem t-eobin t-eolottery t-eo2dVector t-eogeneration t-eoEasyEA\
 	t-eoNonUniform t-eoUniform t-eoRandom t-parser t-eoESFull t-eoESOps\
-	t-eoAtomOps t-selectOne
+	t-eoAtomOps t-selectOne t-eoaltbreeder t-eoGeneralOps t-eoGOpSel \
+	t-eoVector
+
+###############################################################################
+
+t_eoVector_SOURCES = t-eoVector.cpp
+t_eoVector_DEPENDENCIES = $(DEPS)
+t_eoVector_LDFLAGS = -lm
+t_eoVector_LDADD = $(LDADDS)
+
+###############################################################################
+
+t_eoGOpSel_SOURCES = t-eoGOpSel.cpp
+t_eoGOpSel_DEPENDENCIES = $(DEPS)
+t_eoGOpSel_LDFLAGS = -lm
+t_eoGOpSel_LDADD = $(LDADDS)
+
+###############################################################################
+
+t_eoGeneralOps_SOURCES = t-eoGeneralOps.cpp
+t_eoGeneralOps_DEPENDENCIES = $(DEPS)
+t_eoGeneralOps_LDFLAGS = -lm
+t_eoGeneralOps_LDADD = $(LDADDS)
+
+###############################################################################
+
+t_eoaltbreeder_SOURCES = t-eoaltbreeder.cpp
+t_eoaltbreeder_DEPENDENCIES = $(DEPS)
+t_eoaltbreeder_LDFLAGS = -lm
+t_eoaltbreeder_LDADD = $(LDADDS)
 
 ###############################################################################
 

eo/test/Makefile.in

@@ -1,4 +1,4 @@
-# Makefile.in generated automatically by automake 1.4 from Makefile.am
+# Makefile.in generated automatically by automake 1.4a from Makefile.am
 
 # Copyright (C) 1994, 1995-8, 1999 Free Software Foundation, Inc.
 # This Makefile.in is free software; the Free Software Foundation
@@ -49,9 +49,10 @@ AUTOMAKE = @AUTOMAKE@
 AUTOHEADER = @AUTOHEADER@
 
 INSTALL = @INSTALL@
-INSTALL_PROGRAM = @INSTALL_PROGRAM@ $(AM_INSTALL_PROGRAM_FLAGS)
+INSTALL_PROGRAM = @INSTALL_PROGRAM@
 INSTALL_DATA = @INSTALL_DATA@
 INSTALL_SCRIPT = @INSTALL_SCRIPT@
+INSTALL_STRIP_FLAG =
 transform = @program_transform_name@
 
 NORMAL_INSTALL = :
@@ -72,9 +73,9 @@ LN_S = @LN_S@
 MAINT = @MAINT@
 MAKEINFO = @MAKEINFO@
 NM = @NM@
-OBJDUMP = @OBJDUMP@
 PACKAGE = @PACKAGE@
 RANLIB = @RANLIB@
+USE_SYMBOL_UNDERSCORE = @USE_SYMBOL_UNDERSCORE@
 VERSION = @VERSION@
 
 DEPS = $(top_builddir)/src/libeo.a
@@ -87,9 +88,37 @@ LDADDS = $(top_builddir)/src/libeo.a
 
 ###############################################################################
 
-noinst_PROGRAMS = t-eobreeder t-eoinclusion t-eoinsertion t-eo t-eofitness 	t-eoproblem t-eobin t-eolottery t-eo2dVector t-eogeneration t-eoEasyEA 	t-eoNonUniform t-eoUniform t-eoRandom t-parser t-eoESFull t-eoESOps 	t-eoAtomOps t-selectOne
+noinst_PROGRAMS = t-eobreeder t-eoinclusion t-eoinsertion t-eo t-eofitness 	t-eoproblem t-eobin t-eolottery t-eo2dVector t-eogeneration t-eoEasyEA 	t-eoNonUniform t-eoUniform t-eoRandom t-parser t-eoESFull t-eoESOps 	t-eoAtomOps t-selectOne t-eoaltbreeder t-eoGeneralOps t-eoGOpSel 	t-eoVector
 
 
+###############################################################################
+
+t_eoVector_SOURCES = t-eoVector.cpp
+t_eoVector_DEPENDENCIES = $(DEPS)
+t_eoVector_LDFLAGS = -lm
+t_eoVector_LDADD = $(LDADDS)
+
+###############################################################################
+
+t_eoGOpSel_SOURCES = t-eoGOpSel.cpp
+t_eoGOpSel_DEPENDENCIES = $(DEPS)
+t_eoGOpSel_LDFLAGS = -lm
+t_eoGOpSel_LDADD = $(LDADDS)
+
+###############################################################################
+
+t_eoGeneralOps_SOURCES = t-eoGeneralOps.cpp
+t_eoGeneralOps_DEPENDENCIES = $(DEPS)
+t_eoGeneralOps_LDFLAGS = -lm
+t_eoGeneralOps_LDADD = $(LDADDS)
+
+###############################################################################
+
+t_eoaltbreeder_SOURCES = t-eoaltbreeder.cpp
+t_eoaltbreeder_DEPENDENCIES = $(DEPS)
+t_eoaltbreeder_LDFLAGS = -lm
+t_eoaltbreeder_LDADD = $(LDADDS)
+
 ###############################################################################
 
 t_selectOne_SOURCES = t-selectOne.cpp
@@ -250,6 +279,10 @@ t_eoESFull_OBJECTS =  t-eoESFull.o
 t_eoESOps_OBJECTS =  t-eoESOps.o
 t_eoAtomOps_OBJECTS =  t-eoAtomOps.o
 t_selectOne_OBJECTS =  t-selectOne.o
+t_eoaltbreeder_OBJECTS =  t-eoaltbreeder.o
+t_eoGeneralOps_OBJECTS =  t-eoGeneralOps.o
+t_eoGOpSel_OBJECTS =  t-eoGOpSel.o
+t_eoVector_OBJECTS =  t-eoVector.o
 CXXFLAGS = @CXXFLAGS@
 CXXCOMPILE = $(CXX) $(DEFS) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(AM_CXXFLAGS) $(CXXFLAGS)
 LTCXXCOMPILE = $(LIBTOOL) --mode=compile $(CXX) $(DEFS) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(AM_CXXFLAGS) $(CXXFLAGS)
@@ -267,8 +300,8 @@ DISTFILES = $(DIST_COMMON) $(SOURCES) $(HEADERS) $(TEXINFOS) $(EXTRA_DIST)
 
 TAR = gtar
 GZIP_ENV = --best
-SOURCES = $(t_eobreeder_SOURCES) $(t_eoinclusion_SOURCES) $(t_eoinsertion_SOURCES) $(t_eo_SOURCES) $(t_eofitness_SOURCES) $(t_eoproblem_SOURCES) $(t_eobin_SOURCES) $(t_eolottery_SOURCES) $(t_eo2dVector_SOURCES) $(t_eogeneration_SOURCES) $(t_eoEasyEA_SOURCES) $(t_eoNonUniform_SOURCES) $(t_eoUniform_SOURCES) $(t_eoRandom_SOURCES) $(t_parser_SOURCES) $(t_eoESFull_SOURCES) $(t_eoESOps_SOURCES) $(t_eoAtomOps_SOURCES) $(t_selectOne_SOURCES)
+SOURCES = $(t_eobreeder_SOURCES) $(t_eoinclusion_SOURCES) $(t_eoinsertion_SOURCES) $(t_eo_SOURCES) $(t_eofitness_SOURCES) $(t_eoproblem_SOURCES) $(t_eobin_SOURCES) $(t_eolottery_SOURCES) $(t_eo2dVector_SOURCES) $(t_eogeneration_SOURCES) $(t_eoEasyEA_SOURCES) $(t_eoNonUniform_SOURCES) $(t_eoUniform_SOURCES) $(t_eoRandom_SOURCES) $(t_parser_SOURCES) $(t_eoESFull_SOURCES) $(t_eoESOps_SOURCES) $(t_eoAtomOps_SOURCES) $(t_selectOne_SOURCES) $(t_eoaltbreeder_SOURCES) $(t_eoGeneralOps_SOURCES) $(t_eoGOpSel_SOURCES) $(t_eoVector_SOURCES)
-OBJECTS = $(t_eobreeder_OBJECTS) $(t_eoinclusion_OBJECTS) $(t_eoinsertion_OBJECTS) $(t_eo_OBJECTS) $(t_eofitness_OBJECTS) $(t_eoproblem_OBJECTS) $(t_eobin_OBJECTS) $(t_eolottery_OBJECTS) $(t_eo2dVector_OBJECTS) $(t_eogeneration_OBJECTS) $(t_eoEasyEA_OBJECTS) $(t_eoNonUniform_OBJECTS) $(t_eoUniform_OBJECTS) $(t_eoRandom_OBJECTS) $(t_parser_OBJECTS) $(t_eoESFull_OBJECTS) $(t_eoESOps_OBJECTS) $(t_eoAtomOps_OBJECTS) $(t_selectOne_OBJECTS)
+OBJECTS = $(t_eobreeder_OBJECTS) $(t_eoinclusion_OBJECTS) $(t_eoinsertion_OBJECTS) $(t_eo_OBJECTS) $(t_eofitness_OBJECTS) $(t_eoproblem_OBJECTS) $(t_eobin_OBJECTS) $(t_eolottery_OBJECTS) $(t_eo2dVector_OBJECTS) $(t_eogeneration_OBJECTS) $(t_eoEasyEA_OBJECTS) $(t_eoNonUniform_OBJECTS) $(t_eoUniform_OBJECTS) $(t_eoRandom_OBJECTS) $(t_parser_OBJECTS) $(t_eoESFull_OBJECTS) $(t_eoESOps_OBJECTS) $(t_eoAtomOps_OBJECTS) $(t_selectOne_OBJECTS) $(t_eoaltbreeder_OBJECTS) $(t_eoGeneralOps_OBJECTS) $(t_eoGOpSel_OBJECTS) $(t_eoVector_OBJECTS)
 
 all: all-redirect
 .SUFFIXES:
@@ -403,6 +436,22 @@ t-eoAtomOps: $(t_eoAtomOps_OBJECTS) $(t_eoAtomOps_DEPENDENCIES)
 t-selectOne: $(t_selectOne_OBJECTS) $(t_selectOne_DEPENDENCIES)
 	@rm -f t-selectOne
 	$(CXXLINK) $(t_selectOne_LDFLAGS) $(t_selectOne_OBJECTS) $(t_selectOne_LDADD) $(LIBS)
+
+t-eoaltbreeder: $(t_eoaltbreeder_OBJECTS) $(t_eoaltbreeder_DEPENDENCIES)
+	@rm -f t-eoaltbreeder
+	$(CXXLINK) $(t_eoaltbreeder_LDFLAGS) $(t_eoaltbreeder_OBJECTS) $(t_eoaltbreeder_LDADD) $(LIBS)
+
+t-eoGeneralOps: $(t_eoGeneralOps_OBJECTS) $(t_eoGeneralOps_DEPENDENCIES)
+	@rm -f t-eoGeneralOps
+	$(CXXLINK) $(t_eoGeneralOps_LDFLAGS) $(t_eoGeneralOps_OBJECTS) $(t_eoGeneralOps_LDADD) $(LIBS)
+
+t-eoGOpSel: $(t_eoGOpSel_OBJECTS) $(t_eoGOpSel_DEPENDENCIES)
+	@rm -f t-eoGOpSel
+	$(CXXLINK) $(t_eoGOpSel_LDFLAGS) $(t_eoGOpSel_OBJECTS) $(t_eoGOpSel_LDADD) $(LIBS)
+
+t-eoVector: $(t_eoVector_OBJECTS) $(t_eoVector_DEPENDENCIES)
+	@rm -f t-eoVector
+	$(CXXLINK) $(t_eoVector_LDFLAGS) $(t_eoVector_OBJECTS) $(t_eoVector_LDADD) $(LIBS)
 .cc.o:
 	$(CXXCOMPILE) -c $<
 .cc.lo:
@@ -449,7 +498,7 @@ distdir: $(DISTFILES)
 	@for file in $(DISTFILES); do \
 	  d=$(srcdir); \
 	  if test -d $$d/$$file; then \
-	    cp -pr $$/$$file $(distdir)/$$file; \
+	    cp -pr $$d/$$file $(distdir)/$$file; \
 	  else \
 	    test -f $(distdir)/$$file \
 	    || ln $$d/$$file $(distdir)/$$file 2> /dev/null \
@@ -478,7 +527,7 @@ uninstall: uninstall-am
 all-am: Makefile $(PROGRAMS)
 all-redirect: all-am
 install-strip:
-	$(MAKE) $(AM_MAKEFLAGS) AM_INSTALL_PROGRAM_FLAGS=-s install
+	$(MAKE) $(AM_MAKEFLAGS) INSTALL_STRIP_FLAG=-s install
 installdirs:
 
 

eo/test/binary_value.h

@@ -8,11 +8,11 @@ typedef eoBin<float> Chrom;
     the fitnes.
     @param _chrom A binary chromosome 
 */
-void binary_value(Chrom& _chrom)
+float binary_value(const Chrom& _chrom)
 {
   float sum = 0;
   for (unsigned i = 0; i < _chrom.size(); i++)
     if (_chrom[i])
       sum += pow(2, _chrom.size() - i - 1);
-  _chrom.fitness(sum);
+  return sum;
 }

eo/test/real_value.h

@@ -8,7 +8,7 @@ typedef vector<double> Vec;
     to -sphere (we'll see later how to minimize rather than maximize!)
     @param _ind A floatingpoint vector 
 */
-float the_real_value(Vec& _ind)
+float real_value(const eoESFullChrom<float>& _ind)
 {
   double sum = 0;      /* compute in double format, even if return a float */
   for (unsigned i = 0; i < _ind.size(); i++)
@@ -16,8 +16,5 @@ float the_real_value(Vec& _ind)
   return -sum;
 }
 
-typedef eoESFullChrom<float> Ind;
 
-void real_value(Ind & _ind) {
+
-    _ind.fitness( the_real_value(_ind) );
-}

eo/test/t-eoAtomOps.cpp

@@ -1,4 +1,29 @@
-// Program to test several EO-ES features
+/* -*- mode: c++; c-indent-level: 4; c++-member-init-indent: 8; comment-column: 35; -*-
+
+    t-eoAtomOps.cpp
+      Program that tests the atomic operator classes
+
+    (c) GeNeura Team, 1999 
+ 
+    This program is free software; you can redistribute it and/or modify
+    it under the terms of the GNU General Public License as published by
+    the Free Software Foundation; either version 2 of the License, or
+    (at your option) any later version.
+
+    This program 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 General Public License for more details.
+
+    You should have received a copy of the GNU General Public License
+    along with this program; 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
+            
+*/
+
+//-----------------------------------------------------------------------------// 
 
 #ifdef _MSC_VER
 #pragma warning(disable:4786)
@@ -19,15 +44,23 @@ using namespace std;
 // Several EOs
 #include <eoString.h>
 
+// RNGs
+#include <eoNegExp.h>
+
 main(int argc, char *argv[]) {
   eoString<float> aString("123456");
   eoAtomCreep<char> creeper;
   eoAtomMutation< eoString<float> > mutator( creeper, 0.5 );
 
-  cout << "Before aString " << aString;
+  eoNegExp<char> charNE( 2 );
-  mutator( aString);
+  eoAtomRandom<char> randomer( charNE );
-  cout << " after mutator " << aString;
+  eoAtomMutation<  eoString<float> > mutator2 ( randomer, 0.5 );
 
+  cout << "Before aString " << aString << endl;
+  mutator( aString);
+  cout << " after mutator " << aString << endl;
+  mutator2( aString);
+  cout << " after mutator2 " << aString << endl;;
   return 0; // to avoid VC++ complaints
 }
 

eo/test/t-eoGOpSel.cpp

@@ -0,0 +1,107 @@
+/* -*- mode: c++; c-indent-level: 4; c++-member-init-indent: 8; comment-column: 35; -*-
+
+    t-eoGOpSel.cpp
+      Testing proportional operator selectors
+
+    (c) Maarten Keijzer and GeNeura Team, 2000 
+ 
+    This program is free software; you can redistribute it and/or modify
+    it under the terms of the GNU General Public License as published by
+    the Free Software Foundation; either version 2 of the License, or
+    (at your option) any later version.
+
+    This program 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 General Public License for more details.
+
+    You should have received a copy of the GNU General Public License
+    along with this program; 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
+            
+*/
+
+//-----------------------------------------------------------------------------// 
+
+// to avoid long name warnings
+#pragma warning(disable:4786)
+
+#include "eoBin.h"  // eoBin, eoPop, eoBreeder
+#include <eoPop.h>
+#include <eoBitOp.h>
+#include <eoProportionalGOpSel.h>
+//#include <eoAltBreeder.h>
+
+
+// Fitness evaluation
+#include "binary_value.h"
+
+//-----------------------------------------------------------------------------
+
+typedef eoBin<float> Chrom;
+
+//-----------------------------------------------------------------------------
+
+main()
+{
+  const unsigned POP_SIZE = 8, CHROM_SIZE = 4;
+  unsigned i;
+
+  eoUniform<Chrom::Type> uniform(false, true);
+  eoBinRandom<Chrom> random;
+  eoPop<Chrom> pop; 
+  
+  for (i = 0; i < POP_SIZE; ++i)
+    {
+      Chrom chrom(CHROM_SIZE);
+      random(chrom);
+      chrom.fitness(binary_value(chrom));
+      pop.push_back(chrom);
+    }
+  
+  cout << "population:" << endl;
+  for (i = 0; i < pop.size(); ++i)
+    cout << pop[i] << " " << pop[i].fitness() << endl;
+
+  eoBinBitFlip<Chrom> bitflip;
+  eoBinCrossover<Chrom> xover;
+  
+  //Create the proportional operator selector and add the 
+  // two operators creatd above to it.
+
+  eoProportionalGOpSel<Chrom > propSel;
+  propSel.addOp(bitflip, 0.5);
+  propSel.addOp(xover, 0.5);
+  for ( i = 0; i < POP_SIZE; i ++ ) {
+    eoGeneralOp<Chrom>& foo =  propSel.selectOp();
+    cout << foo.nInputs() << " " 
+	 << foo.nOutputs()  << endl;
+  }
+  
+ //  eoAltBreeder<Chrom> breeder( propSel );
+  
+  
+
+//   breeder(pop);
+
+//   eoSequentialOpSelector<Chrom,   eoAltBreeder<Chrom>::outIt > seqSel;
+
+//   eoAltBreeder<Chrom> breeder2( seqSel );
+//   seqSel.addOp(bitflip, 0.25);
+//   seqSel.addOp(xover, 0.75);
+
+//   breeder2(pop);
+
+//   // reevaluation of fitness 
+//   for_each(pop.begin(), pop.end(), binary_value);
+
+//   cout << "new population:" << endl;
+//   for (i = 0; i < pop.size(); ++i)
+//     cout << pop[i] << " " << pop[i].fitness() << endl;
+
+  return 0;
+}
+
+//-----------------------------------------------------------------------------

eo/test/t-eoGeneralOps.cpp

@@ -0,0 +1,71 @@
+/* -*- mode: c++; c-indent-level: 4; c++-member-init-indent: 8; comment-column: 35; -*-
+
+    t-eoGeneralOps.cpp
+      Program that tests the General operator interface, and the wrappers
+      for monary and unary operators.
+
+    (c) GeNeura Team, 1999 
+ 
+    This program is free software; you can redistribute it and/or modify
+    it under the terms of the GNU General Public License as published by
+    the Free Software Foundation; either version 2 of the License, or
+    (at your option) any later version.
+
+    This program 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 General Public License for more details.
+
+    You should have received a copy of the GNU General Public License
+    along with this program; 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
+            
+*/
+
+//-----------------------------------------------------------------------------// 
+
+#ifdef _MSC_VER
+#pragma warning(disable:4786)
+#endif 
+
+#include <string>
+#include <iostream>
+#include <iterator>
+
+using namespace std;
+
+// Operators we are going to test
+#include <eoAtomCreep.h>
+#include <eoAtomBitFlip.h>
+#include <eoAtomRandom.h>
+#include <eoAtomMutation.h>
+
+// Several EOs
+#include <eoString.h>
+
+// generalOp we are testing
+#include <eoGeneralOp.h>
+
+main(int argc, char *argv[]) {
+  eoString<float> aString("123456");
+  eoAtomCreep<char> creeper;
+  eoAtomMutation< eoString<float> > mutator( creeper, 0.5 );
+
+  eoWrappedMonOp< eoString<float> > wCreeper( mutator );
+  cout << "Before aString " << aString;
+  mutator( aString);
+  cout << " after mutator " << aString;
+
+  // Test now the alternative interface
+  eoPop< eoString<float> > vIn, vOut;
+  insert_iterator<eoPop<eoString<float> > > ins( vOut, vOut.begin() );
+  vIn.push_back( aString );
+  wCreeper( vIn.begin(), ins );
+
+  cout << endl << "Before " << vIn[0] << endl << " after " << vOut[0] << endl;;
+  
+  return 0; // to avoid VC++ complaints
+}
+

eo/test/t-eoRandom.cpp

@@ -1,22 +1,22 @@
-// -*- 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; -*-
 
-/*-----------------------------------------------------------------------------
+    t-eoRandom.cpp
- * t-eoRandom
+      Test program for random generator
- *    Testing program for the eoRNG class
- * (c) GeNeura Team, 1999 
 
-    This library is free software; you can redistribute it and/or
+    (c) GeNeura Team, 1999 
-    modify it under the terms of the GNU 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,
+    This program is free software; you can redistribute it and/or modify
+    it under the terms of the GNU General Public License as published by
+    the Free Software Foundation; either version 2 of the License, or
+    (at your option) any later version.
+
+    This program 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
+    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-    Lesser General Public License for more details.
+    GNU General Public License for more details.
 
-    You should have received a copy of the GNU Lesser General Public
+    You should have received a copy of the GNU General Public License
-    License along with this library; if not, write to the Free Software
+    along with this program; 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
@@ -25,7 +25,6 @@
 
 //-----------------------------------------------------------------------------
 
-
 #include <iostream>   // cout
 #include <strstream>  // ostrstream, istrstream
 #include <eoUniform.h>         // eoBin

eo/test/t-eoVector.cpp

@@ -0,0 +1,57 @@
+/* -*- mode: c++; c-indent-level: 4; c++-member-init-indent: 8; comment-column: 35; -*-
+
+    t-eoVectpr.cpp
+      This program tests vector-like chromosomes
+    (c) GeNeura Team, 1999, 2000
+ 
+    This program is free software; you can redistribute it and/or modify
+    it under the terms of the GNU General Public License as published by
+    the Free Software Foundation; either version 2 of the License, or
+    (at your option) any later version.
+
+    This program 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 General Public License for more details.
+
+    You should have received a copy of the GNU General Public License
+    along with this program; 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
+            
+*/
+//-----------------------------------------------------------------------------
+
+#include <iostream>   // cout
+#include <strstream>  // ostrstream, istrstream
+
+#include <eoUniform.h>
+#include <eoVector.h>         // eoVector
+#include <eo1dWDistance.h>
+
+//-----------------------------------------------------------------------------
+
+typedef eoVector<float> Chrom;
+
+//-----------------------------------------------------------------------------
+
+main()
+{
+  const unsigned SIZE = 4;
+  unsigned i, j;
+  eoUniform<Chrom::Type> uniform(-1,1);
+
+  Chrom chrom1(SIZE,uniform), chrom2( SIZE, uniform);
+  
+  cout << "chrom1:  " << chrom1 << endl <<
+    "chrom2:  " << chrom2 << endl;
+  
+  eo1dWDistance< float, float > chromDist( chrom1 );
+  cout << "Distance from chrom1 to chrom2 " << chromDist.distance( chrom2 ) << endl;
+  
+  
+  return 0;
+}
+
+//-----------------------------------------------------------------------------

eo/test/t-eoaltbreeder.cpp

@@ -0,0 +1,98 @@
+/* -*- mode: c++; c-indent-level: 4; c++-member-init-indent: 8; comment-column: 35; -*-
+
+    t-eoaltbreeder.cpp
+      Extensive esting of the eoAltBreeder class
+
+    (c) Maarten Keijzer and GeNeura Team, 2000 
+ 
+    This program is free software; you can redistribute it and/or modify
+    it under the terms of the GNU General Public License as published by
+    the Free Software Foundation; either version 2 of the License, or
+    (at your option) any later version.
+
+    This program 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 General Public License for more details.
+
+    You should have received a copy of the GNU General Public License
+    along with this program; 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
+            
+*/
+
+//-----------------------------------------------------------------------------// 
+
+// to avoid long name warnings
+#pragma warning(disable:4786)
+
+#include "eoBin.h"  // eoBin, eoPop, eoBreeder
+#include <eoPop.h>
+#include <eoBitOp.h>
+#include <eoProportionalOpSel.h>
+#include <eoAltBreeder.h>
+
+
+// Fitness evaluation
+#include "binary_value.h"
+
+//-----------------------------------------------------------------------------
+
+typedef eoBin<float> Chrom;
+
+//-----------------------------------------------------------------------------
+
+main()
+{
+  const unsigned POP_SIZE = 8, CHROM_SIZE = 4;
+  unsigned i;
+
+  eoUniform<Chrom::Type> uniform(false, true);
+  eoBinRandom<Chrom> random;
+  eoPop<Chrom> pop; 
+  
+  for (i = 0; i < POP_SIZE; ++i)
+    {
+      Chrom chrom(CHROM_SIZE);
+      random(chrom);
+      binary_value(chrom);
+      pop.push_back(chrom);
+    }
+  
+  cout << "population:" << endl;
+  for (i = 0; i < pop.size(); ++i)
+    cout << pop[i] << " " << pop[i].fitness() << endl;
+
+  eoBinBitFlip<Chrom> bitflip;
+  eoBinCrossover<Chrom> xover;
+  
+  eoProportionalOpSelector<Chrom, eoAltBreeder<Chrom>::outIt > propSel;
+  
+  eoAltBreeder<Chrom> breeder( propSel );
+  
+  propSel.addOp(bitflip, 0.25);
+  propSel.addOp(xover, 0.75);
+
+  breeder(pop);
+
+  eoSequentialOpSelector<Chrom,   eoAltBreeder<Chrom>::outIt > seqSel;
+
+  eoAltBreeder<Chrom> breeder2( seqSel );
+  seqSel.addOp(bitflip, 0.25);
+  seqSel.addOp(xover, 0.75);
+
+  breeder2(pop);
+
+  // reevaluation of fitness 
+  for_each(pop.begin(), pop.end(), binary_value);
+
+  cout << "new population:" << endl;
+  for (i = 0; i < pop.size(); ++i)
+    cout << pop[i] << " " << pop[i].fitness() << endl;
+
+  return 0;
+}
+
+//-----------------------------------------------------------------------------

eo/test/t-eobin.cpp

@@ -1,22 +1,21 @@
-// -*- 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; -*-
 
-//-----------------------------------------------------------------------------
+    t-eobin.cpp
-// t-eobin.cpp
+      This program tests the the binary cromosomes and several genetic operators
-//   This program test the the binary cromosomes and several genetic operators
+    (c) GeNeura Team, 1999 
-// (c) GeNeura Team, 1999 
-/* 
-    This library is free software; you can redistribute it and/or
-    modify it under the terms of the GNU 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,
+    This program is free software; you can redistribute it and/or modify
+    it under the terms of the GNU General Public License as published by
+    the Free Software Foundation; either version 2 of the License, or
+    (at your option) any later version.
+
+    This program 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
+    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-    Lesser General Public License for more details.
+    GNU General Public License for more details.
 
-    You should have received a copy of the GNU Lesser General Public
+    You should have received a copy of the GNU General Public License
-    License along with this library; if not, write to the Free Software
+    along with this program; 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

eo/test/t-eogeneration.cpp

@@ -1,11 +1,38 @@
-//-----------------------------------------------------------------------------
+/* -*- mode: c++; c-indent-level: 4; c++-member-init-indent: 8; comment-column: 35; -*-
-// t-eogeneration.cpp
+
-//-----------------------------------------------------------------------------
+    t-eogeneration.cpp
+      Testing the eoGeneration classes, and classes related to it
+
+    (c) GeNeura Team, 1999, 2000
+ 
+    This program is free software; you can redistribute it and/or modify
+    it under the terms of the GNU General Public License as published by
+    the Free Software Foundation; either version 2 of the License, or
+    (at your option) any later version.
+
+    This program 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 General Public License for more details.
+
+    You should have received a copy of the GNU General Public License
+    along with this program; 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
+            
+*/
+
+//-----------------------------------------------------------------------------// 
+
 
 // to avoid long name warnings
+#ifdef _MSC_VER
 #pragma warning(disable:4786)
+#endif 
 
-#include <eo>
+#include <eoGeneration.h>
+#include <eoEvalFuncPtrCnt.h>
 
 #include "binary_value.h"
 
@@ -23,12 +50,14 @@ main()
   eoUniform<Chrom::Type> uniform(false, true);
   eoBinRandom<Chrom> random;
   eoPop<Chrom> pop; 
+  // Evaluation
+  eoEvalFuncPtr<Chrom> eval( binary_value );
 
   for (i = 0; i < POP_SIZE; ++i)
     {
       Chrom chrom(CHROM_SIZE);
       random(chrom);
-      binary_value(chrom);
+      eval(chrom);
       pop.push_back(chrom);
     }
   
@@ -51,8 +80,7 @@ main()
   // replacement
   eoInclusion<Chrom> inclusion;
 
-  // Evaluation
+  
-  eoEvalFuncPtr<Chrom> eval(  binary_value );
 
   // GA generation
   eoGeneration<Chrom> generation(lottery, breeder, inclusion, eval);
@@ -76,6 +104,41 @@ main()
     
   } while (pop[0].fitness() < pow(2.0, CHROM_SIZE) - 1);
 
+  // Try again, with a "counted" evaluation function
+  // GA generation
+  // Evaluation
+  eoEvalFuncPtrCnt<Chrom> eval2( binary_value );
+  eoPop<Chrom> pop2; 
+  
+  for (i = 0; i < POP_SIZE; ++i)
+    {
+      Chrom chrom(CHROM_SIZE);
+      random(chrom);
+      binary_value(chrom);
+      eval2(chrom);
+      pop2.push_back(chrom);
+    }
+  eoGeneration<Chrom> generation2(lottery, breeder, inclusion, eval2);
+  
+  // evolution
+  do {
+    try
+      {
+	generation2(pop2);
+      }
+    catch (exception& e)
+      {
+	cout << "exception: " << e.what() << endl;;
+	exit(EXIT_FAILURE);
+      }
+    
+    cout << "pop[" << ++g << "]" << endl;
+    for (i = 0; i < pop2.size(); ++i)
+      cout << "\t" <<  pop2[i] << " " << pop[i].fitness() << endl;
+    
+  } while (pop2[0].fitness() < pow(2.0, CHROM_SIZE) - 1);
+
+  cout << "Number of evaluations " << eval2.getNumOfEvaluations() << endl;
   return 0;
 }
 

eo/win/Makefile.am

@@ -1,3 +1,4 @@
+#Some dsps are missing here
 EXTRA_DIST=EO.dsw random.dsp t_eoinsertion.dsp t_ops.dsp\
 	atomops.dsp  t_eoaged.dsp     t_eornd.dsp        t_opsel.dsp\
 	t_eobin.dsp      t_eostring.dsp     t_opselmason.dsp\