Added symbolic regression, which tests combined ops as well

eo/src/Makefile.am

@@ -4,7 +4,7 @@
 ##
 ###############################################################################
 
-SUBDIRS = es ga utils other
+SUBDIRS = es ga gp utils other
 
 lib_LIBRARIES = libeo.a
 libeo_a_SOURCES = eoPrintable.cpp eoPersistent.cpp eoFunctorStore.cpp 

eo/src/eoGOpBreeder.h

@@ -24,7 +24,7 @@ class eoGOpBreeder: public eoUnaryFunctor<void, eoPop<EOT>&>
  public:
   /// Default constructor.
   eoGOpBreeder( eoGOpSelector<EOT>& _opSel,
-                    eoPopIndiSelector<EOT>& _selector) 
+                    eoSelectOneIndiSelector<EOT>& _selector) 
                     : opSel( _opSel ), selector(_selector) 
         {}
   
@@ -47,7 +47,7 @@ class eoGOpBreeder: public eoUnaryFunctor<void, eoPop<EOT>&>
   
  private:
   eoGOpSelector<EOT>&            opSel;
-  eoPopIndiSelector<EOT>&     selector;
+  eoSelectOneIndiSelector<EOT>&     selector;
   
   // the inserter can be local as there's no point in changing it from the outside
   eoBackInserter<EOT>     inserter;

eo/src/eoPop.h

@@ -185,78 +185,5 @@ class eoPop: public vector<EOT>, public eoObject, public eoPersistent
 
 };
 
-/**
-    Keeps and calculates information about a population such
-    as the sum of fitnesses and whether the population is sorted.
-    It can be used to cache information about a population between
-    calls of functors, see for instance how this makes eoProportional
-    just this tat more efficient 
-
-    @see eoSelectOne, eoSelect, eoProportional
-
-template <class EOT>
-class eoPopStats 
-{
-public :
-    typedef typename EOT::Fitness FitnessType;
-
-    /// Initialize by stating nothing is known
-    eoPopStats() : 
-        sum_fitness_calculated(false), 
-        pop_sorted_calculated(false) 
-    {}
-
-    /// Call this function after the pop might have/is changed
-    void reset()
-    {
-        sum_fitness_calculated = false;
-        pop_sorted_calculated = false;
-    }
-
-    /// Calculate sum_fitness or return cached value
-    FitnessType get_sum_fitness(const eoPop<EOT>& _pop)
-    {
-        if (sum_fitness_calculated)
-            return sum_fitness;
-
-        sum_fitness = 0.0;
-
-        for (int i = 0; i < _pop.size(); ++i)
-        {
-            sum_fitness += _pop[i].fitness();
-        }
-
-        sum_fitness_calculated = true;
-        return sum_fitness;
-    }
-
-    /// Check if the pop is sorted or return cached_value
-    bool is_pop_sorted(const eoPop<EOT>& _pop)
-    {
-        if (pop_sorted_calculated)
-            return pop_sorted;
-        
-        int i;
-        for (i = 1; i < _pop.size(); ++i)
-        {
-            if (!(_pop[i-1] < _pop[i]))
-            { // not in sort order
-                break;
-            }
-        }
-
-        pop_sorted = (i == _pop.size());
-        pop_sorted_calculated = true;
-        return pop_sorted;
-    }
-
-    bool        sum_fitness_calculated;
-    FitnessType sum_fitness;
-
-    bool        pop_sorted_calculated;
-    bool        pop_sorted;
-};
-*/
-
 #endif
 

eo/src/eoSequentialGOpSel.h

@@ -40,12 +40,10 @@ template <class EOT>
 class eoSequentialGOpSel : public eoGOpSelector<EOT>
 {
 public :
-  
+    
-  eoSequentialGOpSel(void) : combined(*this, getRates()) {}
-  
   virtual eoGeneralOp<EOT>& selectOp()
   {    
-    return combined;
+    return combined.bind(*this, getRates());
   }		
   
 private :

eo/src/eoSteadyStateTransform.h

@@ -65,7 +65,7 @@ template<class EOT> class eoSteadyStateTransform: public eoTransform<EOT>
           nSteps = pop.size(); // make a 'generation equivalent'
       }
 
-      for (unsigned i = 0; i < steps; ++i)
+      for (unsigned i = 0; i < nSteps; ++i)
       {
          selector.bind(pop);
          inserter.bind(pop);
@@ -77,7 +77,7 @@ template<class EOT> class eoSteadyStateTransform: public eoTransform<EOT>
   
  private:
   eoGOpSelector<EOT>&         opSelector;
-  eoSelectOneIndiSelector<EOT>&  selector;
+  eoSelectOneIndiSelector<EOT>  selector;
   eoSteadyStateInserter<EOT>& inserter;
   unsigned steps;
 };

eo/src/eoWrappedOps.h

@@ -117,8 +117,12 @@ template <class EOT>
 class eoCombinedOp : public eoGeneralOp<EOT>
 {
     public :
-    eoCombinedOp(const std::vector<eoGeneralOp<EOT>*>& _ops, const std::vector<float>& rates)
+    eoCombinedOp& bind(const std::vector<eoGeneralOp<EOT>*>& _ops, const std::vector<float>& _rates)
-        : ops(_ops), rates(_rates) {}
+    { 
+        ops = &_ops;
+        rates = &_rates;
+        return *this;
+    }
 
     class eoDelayedSelector : public eoIndiSelector<EOT>
     {
@@ -147,7 +151,7 @@ class eoCombinedOp : public eoGeneralOp<EOT>
     };
 
   /** Applies all ops in the combined op
-        It works in the following way
+        It first applies the 
   */
   void operator()( eoIndiSelector<EOT>& _in, 
 			   eoInserter<EOT>& _out ) 
@@ -156,7 +160,7 @@ class eoCombinedOp : public eoGeneralOp<EOT>
         eoPop<EOT> next;
         unsigned i;
 
-        for (i = 0; i < ops.size(); ++i)
+        for (i = 0; i < ops->size(); ++i)
         {
             eoDelayedSelector delay(_in, intermediate);
             inserter.bind(next);
@@ -166,13 +170,13 @@ class eoCombinedOp : public eoGeneralOp<EOT>
             // apply operators until we have as many outputs as inputs
             do
             {
-                if (flip(rates[i])) // should this flip be here?
+                if (rng.flip(rates->operator[](i))) // should this flip be here?
-                    (*ops[i])(delayedSelector, inserter);
+                    (*ops->operator[](i))(delay, inserter);
 
                 counter++;
                 if (counter > 1000) 
                 {
-                    throw logical_error("eoCombinedOp: no termination after 1000 tries, did you forget to insert individuals in your eoGeneralOp?");
+                    throw logic_error("eoCombinedOp: no termination after 1000 tries, did you forget to insert individuals in your eoGeneralOp?");
                 }
             }
             while (next.size() < intermediate.size());
@@ -187,8 +191,8 @@ class eoCombinedOp : public eoGeneralOp<EOT>
   }
 
     private :
-        const std::vector<eoGeneralOp<EOT>*>& ops;
+        const std::vector<eoGeneralOp<EOT>*>* ops;
-        const std::vector<float> rates;
+        const std::vector<float>* rates;
         eoBackInserter<EOT> inserter;
 };
 

eo/src/gp/eoParseTree.h

@@ -17,19 +17,12 @@ template <class FType, class Node>
 class eoParseTree : public EO<FType>, public parse_tree<Node>
 {
 public :
+
+    typedef parse_tree<Node>::subtree Subtree;
+
+    eoParseTree(void) {}
+    eoParseTree(const parse_tree<Node>& tree) : parse_tree<Node>(tree) {}
     
-    typedef typename parse_tree<Node>::subtree Type;
-
-    eoParseTree(void) : EO<FType>(), parse_tree<Node>() {}
-    eoParseTree(unsigned _size, eoRnd<Type>& _rnd) 
-        : EO<FType>(), parse_tree<Node>(_rnd()) 
-    {
-        pruneTree(_size);
-    }
-    eoParseTree(eoRnd<Type>& _rnd) 
-        : EO<FType>(), parse_tree<Node>(_rnd()) 
-    {}
-
     virtual void pruneTree(unsigned _size)
     {
         if (_size < 1)
@@ -37,7 +30,7 @@ public :
 
         if (size() > _size)
         {
-            Type* sub = &operator[](size() - 2); // prune tree
+            Subtree* sub = &operator[](size() - 2); // prune tree
 
             while (sub->size() > _size)
             {
@@ -101,7 +94,7 @@ class eoGpDepthInitializer : public eoInit< eoParseTree<FType, Node> >
 		const vector<Node>& _initializor,
         bool _grow = true) 
             :
-            eoRnd<EoType::Type>(),
+            eoInit<EoType>(),
 			max_depth(_max_depth),
 			initializor(_initializor),
 			grow(_grow) 
@@ -115,7 +108,8 @@ class eoGpDepthInitializer : public eoInit< eoParseTree<FType, Node> >
         
         generate(sequence, max_depth);
         
-        _tree = parse_tree<Node>(sequence.begin(), sequence.end());
+        parse_tree<Node> tmp(sequence.begin(), sequence.end());
+        _tree.swap(tmp);
 	}
 
     void generate(list<Node>& sequence, int the_max, int last_terminal = -1)
@@ -180,10 +174,10 @@ public:
   /// Dtor
   virtual ~eoSubtreeXOver () {};
 
-  void operator()(eoIndiSelector<EoType>& _source, eoInserter<EoType>& _sink ) const
+  void operator()(eoIndiSelector<EoType>& _select, eoInserter<EoType>& _insert )
   {
-      EoType eo1 = _source.select();
+      EoType eo1 = _select();
-      const EoType& eo2 = _source.select();
+      const EoType& eo2 = _select();
 
 	  int i = rng.random(eo1.size());
 	  int j = rng.random(eo2.size());
@@ -193,7 +187,7 @@ public:
 	  eo1.pruneTree(max_length);
 	  
 	  eo1.invalidate();
-      _sink.insert(eo1);
+      _insert(eo1);
   }
 
   unsigned max_length;
@@ -206,7 +200,7 @@ public:
 
   typedef eoParseTree<FType, Node> EoType;
 
-  eoBranchMutation(eoRnd<EoType::Type>& _init, unsigned _max_length)
+  eoBranchMutation(eoInit<EoType>& _init, unsigned _max_length)
     : eoGeneralOp<EoType>(), max_length(_max_length), initializer(_init) 
   {};
 
@@ -215,25 +209,28 @@ public:
   /// Dtor
   virtual ~eoBranchMutation() {};
 
-  void operator()(eoIndiSelector<EoType>& _source, eoInserter<EoType>& _sink ) const
+  void operator()(eoIndiSelector<EoType>& _select, eoInserter<EoType>& _insert ) 
   {
-      EoType eo1 = _source.select();
+      EoType eo1 = _select();
 	  int i = rng.random(eo1.size());
       
-      EoType eo2(eo1[i].size(), initializer); // create random other to cross with
+      EoType eo2;
+      initializer(eo2);
 
-	  eo1[i] = eo2.back(); // insert subtree
+	  int j = rng.random(eo2.size());
+
+	  eo1[i] = eo2[j]; // insert subtree
 	  	  
 	  eo1.pruneTree(max_length);
-
+	  	  
 	  eo1.invalidate();
-      _sink.insert(eo1);
+      _insert(eo1);
   }
 
 private :
 
   unsigned max_length;
-  eoRnd<EoType::Type>& initializer; 
+  eoInit<EoType>& initializer; 
 };
 
 

eo/src/gp/node_pool.h

@@ -148,7 +148,7 @@ public :
         if (arity == 0)
             return 0;
 
-        T* t new T [arity];
+        T* t = new T [arity];
 
         for (int i = 0; i < arity; ++i)
         {

eo/src/gp/parse_tree.h

@@ -16,15 +16,6 @@
  * modified is included with the above copyright notice.
 
 
- * Special disclaimer and political statement: 
-
- * In contrast with the rest of the EO package where you might have found this code, this software 
- * does NOT fall under the GNU Lesser Public License or the GNU Public License, nor is anyone allowed
- * by the copyright holder (that's me) to put it under either license.
- * Doing this would limit my and your freedom to use this software in any way
- * you or I see fit, including but not limited to closed-source software. 
-
-
 
   Usage information.
 
@@ -173,7 +164,7 @@ namespace gp_parse_tree
 
 #include "node_pool.h"
 
-
+/// This ones defined because gcc does not always implement namespaces
 template <class T>
 inline void do_the_swap(T& a, T& b) 
 {
@@ -371,21 +362,20 @@ public :
 
 	void swap(subtree& y)
 	{
-		do_the_swap(content, y.content);
+        do_the_swap(content, y.content);
-		do_the_swap(args, y.args);
+        do_the_swap(args, y.args);
-		do_the_swap(parent, y.parent);
+        
+        adopt();
+        y.adopt();
 
-		do_the_swap(_cumulative_size, y._cumulative_size);
+        do_the_swap(parent, y.parent);
-		do_the_swap(_depth, y._depth);
+
-		do_the_swap(_size, y._size);
+        do_the_swap(_cumulative_size, y._cumulative_size);
+        do_the_swap(_depth, y._depth);
+        do_the_swap(_size, y._size);
 		updateAfterInsert();
 	}
 
-	friend void swap(subtree& x, subtree& y)
-	{
-		x.swap(y);
-	}
-
 protected :
 
 	virtual void updateAfterInsert(void)
@@ -973,7 +963,7 @@ ptrdiff_t*  distance_type(gp_parse_tree::parse_tree<T>::iterator)
 	return 0;
 }
 
-// Put customized swaps also in std...
+/* Put customized swaps also in std...
 
 template<class T> inline
 void swap(gp_parse_tree::parse_tree<T>& a, gp_parse_tree::parse_tree<T>& b)
@@ -985,7 +975,7 @@ template<class T> inline
 void iter_swap(vector<gp_parse_tree::parse_tree<T> >::iterator a, vector<gp_parse_tree::parse_tree<T> > b)
 {
     a->swap(*b);
-}
+}*/
 
 
 } // namespace std

eo/src/utils/eoStat.h

@@ -59,7 +59,7 @@ template <class EOT>
 class eoAverageStat : public eoStat<EOT, double>
 {
 public :
-    eoAverageStat(std::string _description = "AverageFitness") : eoStat<EOT, double>(0.0, _description) {}
+    eoAverageStat(std::string _description = "Average Fitness") : eoStat<EOT, double>(0.0, _description) {}
 
     static double sumFitness(double _sum, const EOT& _eot)
     {
@@ -103,6 +103,20 @@ public :
     }
 };
 
+template <class EOT>
+class eoBestFitnessStat : public eoStat<EOT, typename EOT::Fitness >
+{
+public :
+    typedef typename EOT::Fitness Fitness;
+
+    eoBestFitnessStat(std::string _description = "Best Fitness") : eoStat<EOT, Fitness>(Fitness(), _description) {}
+
+    virtual void operator()(const eoPop<EOT>& _pop)
+    {
+        value() = _pop.nth_element_fitness(0);
+    }
+};
+
 /*
 template <class EOT>
 class eoStdevStat : public eoStat<EOT, double >

eo/test/Makefile.am

@@ -13,7 +13,7 @@ LDADDS = $(top_builddir)/src/libeo.a $(top_builddir)/src/utils/libeoutils.a
 
 ###############################################################################
 
-noinst_PROGRAMS = t-eofitness t-eobin t-eoStateAndParser t-eoCheckpointing t-eoExternalEO t-eoESFull
+noinst_PROGRAMS = t-eofitness t-eobin t-eoStateAndParser t-eoCheckpointing t-eoExternalEO t-eoESFull t-eoSymreg
 
 ###############################################################################
 
@@ -57,4 +57,13 @@ t_eoExternalEO_LDADD = $(LDADDS)
 
 ###############################################################################
 
+###############################################################################
+
+t_eoSymreg_SOURCES = t-eoSymreg.cpp
+t_eoSymreg_DEPENDENCIES = $(DEPS) 
+t_eoSymreg_LDFLAGS = -lm 
+t_eoSymreg_LDADD = $(LDADDS) 
+
+###############################################################################
+
 

eo/test/t-eoSymreg.cpp

@@ -1,7 +1,7 @@
 #pragma warning(disable:4786)
 
-#include "eoParseTree.h"
+#include <gp/eoParseTree.h>
-#include "eoEvalFunc.h"
+#include <eoEvalFunc.h>
 
 using namespace gp_parse_tree;
 using namespace std;
@@ -20,34 +20,43 @@ public :
 
 	// arity function, need this function!
 	int arity(void) const      { return op == X? 0 : 2; }
-	
+
+    void randomize(void) {}
+    
 	// evaluation function, single case, using first argument to give value of variable
 	template <class Children>
-	double operator()(double var, Children args) const
+	void operator()(double& result, Children args, double var) const
 	{
+        double r1, r2;
+
+        if (arity() == 2)
+        {
+            args[0].apply(r1, var);
+            args[1].apply(r2, var);
+        }
+
 		switch (op)
 		{
-		case Plus : return args[0].apply(var) + args[1].apply(var);
+		case Plus : result = r1 + r2; break;
-		case Min  : return args[0].apply(var) - args[1].apply(var);
+		case Min  : result = r1 - r2; break;
-		case Mult : return args[0].apply(var) * args[1].apply(var);
+		case Mult : result = r1 * r2; break;
 		case PDiv : 
 			{
-				double arg1 = args[1].apply(var);
+				if (r2 == 0.0)
-				if (arg1 == 0.0)
+					result = 1.0; // protection a la Koza, realistic implementations should maybe throw an exception
-					return 1.0; // protection a la Koza, realistic implementations should maybe throw an exception
+                else
-
+				    result = r1 / r2;
-				return args[0].apply(var) / arg1;
+                break;
 			}
 
-		case X    : return var; 
+		case X    : result = var; break;
 		}
 
-        return var; // to avoid compiler error
 	}
 
     /// 'Pretty' print to ostream function
     template <class Children>
-        string operator()(string dummy, Children args)
+        void operator()(string& result, Children args) const
     {
         static const string lb = "(";
         static const string rb = ")";
@@ -56,13 +65,16 @@ public :
         
 	    if (arity() == 0)
 		{
-            return string("x");
+            result = "x";
+            return;
         }
         // else
-        string result = lb + args[0].apply(dummy);
+        string r1;
+        args[0].apply(r1);
+        result = lb + r1;
         result += opStr; 
-        result += args[1].apply(dummy) + rb;
+        args[1].apply(r1);
-        return result;
+        result += r1 + rb;
     }
 
     Operator getOp(void) const { return op; }    
@@ -100,15 +112,15 @@ std::istream& operator>>(std::istream& is, SymregNode& eot)
 //-----------------------------------------------------------------------------
 /** Implementation of a function evaluation object. */
 
-float targetFunction(float x)
+double targetFunction(double x)
 { 
-	return x * x * x * x - x * x * x + x * x * x - x * x + x - 1; 
+	return x * x * x * x - x * x * x + x * x * x - x * x + x - 10; 
 }
 
 // parameters controlling the sampling of points
-const float xbegin = -10.0f;
+const double xbegin = -10.0f;
-const float xend   = 10.0f;
+const double xend   = 10.0f;
-const float xstep  = 1.3f; 
+const double xstep  = 1.3f; 
 
 template <class FType, class Node> struct RMS: public eoEvalFunc< eoParseTree<FType, Node> > 
 {
@@ -128,7 +140,7 @@ public :
 
 		int i = 0;
 
-    	for (double x = xbegin; x < xend && i < n; ++i)
+    	for (double x = xbegin; x < xend && i < n; ++i, x+=xstep)
 		{
 			target[i] = targetFunction(x);
 			inputs[i] = x;
@@ -137,7 +149,7 @@ public :
 
     ~RMS() {}
     
-	void operator()( EoType & _eo ) const 
+	void operator()( EoType & _eo )  
 	{
 		vector<double> outputs;
 		outputs.resize(inputs.size());
@@ -146,7 +158,7 @@ public :
         
 		for (int i = 0; i < inputs.size(); ++i)
         {
-		    outputs[i] = _eo.apply(inputs[i]);
+		    _eo.apply(outputs[i], inputs[i]);
 	        fitness += (outputs[i] - target[i]) * (outputs[i] - target[i]);
         }
 		
@@ -164,25 +176,6 @@ private :
 	vector<double> target;
 };
 
-#include "eoTerm.h"
-
-template <class EOT>
-class eoGenerationTerm : public eoTerm<EOT>
-{
-    public :
-        eoGenerationTerm(size_t _ngen) : eoTerm<EOT>(), ngen(_ngen) {}
-
-        bool operator()(const eoPop<EOT>&)
-        {
-            cout << '.'; // pacifier
-            cout.flush();
-
-            return --ngen > 0;
-        }
-    private :
-        unsigned ngen;
-};
-
 template <class EOT, class FitnessType>
 void print_best(eoPop<EOT>& pop)
 {
@@ -201,7 +194,8 @@ void print_best(eoPop<EOT>& pop)
     
     cout << "\t";
         
-    string str = pop[index].apply(string());
+    string str;
+    pop[index].apply(str);
     
     cout << str.c_str();
     cout << endl << "RMS Error = " << pop[index].fitness() << endl;
@@ -210,16 +204,15 @@ void print_best(eoPop<EOT>& pop)
 
 #include <eo>
 #include "eoGOpBreeder.h"
-#include "eoSequentialGOpSelector.h"
+#include "eoSequentialGOpSel.h"
-#include "eoProportionalGOpSelector.h"
+#include "eoProportionalGOpSel.h"
-#include "eoDetTournamentIndiSelector.h"
 #include "eoDetTournamentInserter.h"
 #include "eoSteadyStateEA.h"
 #include "eoScalarFitness.h"
 
 void main()
 {
-    typedef eoScalarFitness<double, greater<double> > FitnessType;
+    typedef eoMinimizingFitness FitnessType;
     typedef SymregNode GpNode;
 
     typedef eoParseTree<FitnessType, GpNode> EoType;
@@ -237,7 +230,9 @@ void main()
     // Root Mean Squared Error Measure
     RMS<FitnessType, GpNode>              eval;
 
-    Pop pop(500, MaxSize, initializer, eval);
+    Pop pop(500, initializer);
+
+    apply<EoType>(eval, pop);
 
     eoSubtreeXOver<FitnessType, GpNode>   xover(MaxSize);
     eoBranchMutation<FitnessType, GpNode> mutation(initializer, MaxSize);
@@ -247,15 +242,28 @@ void main()
     seqSel.addOp(mutation, 0.25);
     seqSel.addOp(xover, 0.75);
   
-    eoDetTournamentIndiSelector<EoType> selector(5);
+    eoDetTournament<EoType> selector(5);
   
     eoDetTournamentInserter<EoType> inserter(eval, 5);
   
     // Terminators
-    eoGenerationTerm<EoType> term(nGenerations);
+    eoGenContinue<EoType> term(nGenerations);
+
+    eoCheckPoint<EoType> checkPoint(term);
+
+    eoAverageStat<EoType>     avg;
+    eoBestFitnessStat<EoType> best;
+    eoStdoutMonitor monitor;
+
+    checkPoint.add(monitor);
+    checkPoint.add(avg);
+    checkPoint.add(best);
+
+    monitor.add(avg);
+    monitor.add(best);
 
     // GP generation
-    eoSteadyStateEA<EoType> gp(seqSel, selector, inserter, term);
+    eoSteadyStateEA<EoType> gp(seqSel, selector, inserter, checkPoint);
 
     cout << "Initialization done" << endl;
 

eo/win/Makefile.am

@@ -1,5 +1,5 @@
 
 EXTRA_DIST=eo_win.dsw eo.dsp esfull.dsp t_eobin.dsp t_eoCheckpointing.dsp t_eofitness.dsp \
-		t_eoFunctor.dsp t_externalEO.dsp t_StateAndParser.dsp
+		t_eoFunctor.dsp t_externalEO.dsp t_StateAndParser.dsp t_eoSymreg.dsp
 
 

eo/win/eo_win.dsw

@@ -75,6 +75,21 @@ Package=<4>
 
 ###############################################################################
 
+Project: "t_eoSymreg"=.\t_eoSymreg.dsp - Package Owner=<4>
+
+Package=<5>
+{{{
+}}}
+
+Package=<4>
+{{{
+    Begin Project Dependency
+    Project_Dep_Name eo
+    End Project Dependency
+}}}
+
+###############################################################################
+
 Project: "t_eobin"=.\t_eobin.dsp - Package Owner=<4>
 
 Package=<5>