refactored vectors repairers that are using a function in a more generic way, added a binary function wrapper for vectors repairers, with the modulus function as an example

edo/src/edo

@@ -59,6 +59,7 @@ Authors:
 #include "edoRepairer.h"
 #include "edoRepairerDispatcher.h"
 #include "edoRepairerRound.h"
+#include "edoRepairerModulo.h"
 #include "edoBounder.h"
 #include "edoBounderNo.h"
 #include "edoBounderBound.h"

edo/src/edoRepairerApply.h

@@ -0,0 +1,98 @@
+/*
+The Evolving Distribution Objects framework (EDO) is a template-based,
+ANSI-C++ evolutionary computation library which helps you to write your
+own estimation of distribution algorithms.
+
+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.1 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., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
+
+Copyright (C) 2011 Thales group
+*/
+/*
+Authors:
+    Johann Dréo <johann.dreo@thalesgroup.com>
+*/
+
+#ifndef _edoRepairerApply_h
+#define _edoRepairerApply_h
+
+#include <algorithm>
+
+#include "edoRepairer.h"
+
+
+template < typename EOT, typename F = typename EOT::AtomType(typename EOT::AtomType) >
+class edoRepairerApply : public edoRepairer<EOT>
+{
+public:
+    edoRepairerApply( F function ) : _function(function) {}
+
+protected:
+    F * _function;
+};
+
+
+/** Apply an arbitrary unary function as a repairer on each item of the solution
+ *
+ * By default, the signature of the expected function is "EOT::AtomType(EOT::AtomType)"
+ *
+ * @ingroup Repairers
+ */
+template < typename EOT, typename F = typename EOT::AtomType(typename EOT::AtomType)>
+class edoRepairerApplyUnary : public edoRepairerApply<EOT,F>
+{
+public:
+    edoRepairerApplyUnary( F function ) : edoRepairerApply<EOT,F>(function) {}
+
+    virtual void operator()( EOT& sol )
+    {
+        std::transform( sol.begin(), sol.end(), sol.begin(), *(this->_function) );
+    }
+};
+
+
+/** Apply an arbitrary binary function as a repairer on each item of the solution,
+ * the second argument of the function being fixed and given at instanciation.
+ *
+ * @see edoRepairerApplyUnary
+ *
+ * @ingroup Repairers
+ */
+template < typename EOT, typename F = typename EOT::AtomType(typename EOT::AtomType, typename EOT::AtomType)>
+class edoRepairerApplyBinary : public edoRepairerApply<EOT,F>
+{
+public:
+    typedef typename EOT::AtomType ArgType;
+
+    edoRepairerApplyBinary(   
+            F function, 
+            ArgType arg 
+        ) : edoRepairerApply<EOT,F>(function), _arg(arg) {}
+
+    virtual void operator()( EOT& sol )
+    {
+        // call the binary function on each item
+        // TODO find a way to use std::transform here? Or would it be too bloated?
+        for(typename EOT::iterator it = sol.begin(); it != sol.end(); ++it ) {
+            *it = (*(this->_function))( *it, _arg );
+        }
+    }
+
+protected:
+    ArgType _arg;
+};
+
+
+#endif // !_edoRepairerApply_h
+

edo/src/edoRepairerModulo.h

@@ -0,0 +1,47 @@
+/*
+The Evolving Distribution Objects framework (EDO) is a template-based,
+ANSI-C++ evolutionary computation library which helps you to write your
+own estimation of distribution algorithms.
+
+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.1 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., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
+
+Copyright (C) 2011 Thales group
+*/
+/*
+Authors:
+    Johann Dréo <johann.dreo@thalesgroup.com>
+*/
+
+#ifndef _edoRepairerModulo_h
+#define _edoRepairerModulo_h
+
+#include <cmath>
+
+#include "edoRepairerApply.h"
+
+/**
+ *
+ * @ingroup Repairers
+ */
+template < typename EOT >
+class edoRepairerModulo: public edoRepairerApplyBinary<EOT>
+{
+public:
+    edoRepairerModulo<EOT>( double denominator ) : edoRepairerApplyBinary<EOT>( std::fmod, denominator ) {}
+};
+
+
+#endif // !_edoRepairerModulo_h
+

edo/src/edoRepairerRound.h

@@ -30,38 +30,32 @@ Authors:
 
 #include <cmath>
 
-#include "edoRepairer.h"
+#include "edoRepairerApply.h"
 
-/**
+/** A repairer that calls "floor" on each items of a solution
+ *
+ * Just a proxy to "edoRepairerApplyUnary<EOT, EOT::AtomType(EOT::AtomType)> rep( std::floor);"
  *
  * @ingroup Repairers
  */
 template < typename EOT >
-class edoRepairerFloor : public edoRepairer<EOT>
+class edoRepairerFloor : public edoRepairerApplyUnary<EOT>
 {
 public:
-    virtual void operator()( EOT& sol )
+    edoRepairerFloor() : edoRepairerApplyUnary<EOT>( std::floor ) {}
-    {
-        for( unsigned int i=0; i < sol.size(); ++i ) {
-            sol[i] = floor( sol[i] );
-        }
-    }
 };
 
-/**
+/** A repairer that calls "ceil" on each items of a solution
+ *
+ * @see edoRepairerFloor
  *
  * @ingroup Repairers
  */
 template < typename EOT >
-class edoRepairerCeil : public edoRepairer<EOT>
+class edoRepairerCeil : public edoRepairerApplyUnary<EOT>
 {
 public:
-    virtual void operator()( EOT& sol )
+    edoRepairerCeil() : edoRepairerApplyUnary<EOT>( std::ceil ) {}
-    {
-        for( unsigned int i=0; i < sol.size(); ++i ) {
-            sol[i] = ceil( sol[i] );
-        }
-    }
 };
 
 

edo/test/CMakeLists.txt

@@ -39,6 +39,7 @@ SET(SOURCES
   t-uniform
   t-continue
   t-dispatcher-round
+  t-repairer-modulo
   )
 
 FOREACH(current ${SOURCES})

edo/test/t-repairer-modulo.cpp

@@ -0,0 +1,55 @@
+/*
+The Evolving Distribution Objects framework (EDO) is a template-based,
+ANSI-C++ evolutionary computation library which helps you to write your
+own estimation of distribution algorithms.
+
+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.1 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., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
+
+Copyright (C) 2010 Thales group
+*/
+/*
+Authors:
+    Johann Dréo <johann.dreo@thalesgroup.com>
+*/
+
+#define _USE_MATH_DEFINES
+#include <math.h>
+
+#include <eo>
+#include <edo>
+#include <es.h>
+
+typedef eoReal< eoMinimizingFitness > EOT;
+
+int main(void)
+{
+    EOT sol;
+    sol.push_back( M_PI * 1 );
+    sol.push_back( M_PI * 2 );
+    sol.push_back( M_PI * 3 );
+    sol.push_back( M_PI * 4 );
+    sol.push_back( M_PI * 4 + M_PI / 2 );
+    sol.push_back( M_PI * 5 + M_PI / 2 );
+    // we expect {pi,0,pi,0,pi/2,pi+pi/2}
+    std::cout << "expect: INVALID  4 3.14159 0 3.14159 0 1.5708 4.71239" << std::endl;
+
+    edoRepairer<EOT>* repare = new edoRepairerModulo<EOT>( 2 * M_PI ); // modulo 2pi
+
+    (*repare)(sol);
+
+    std::cout << sol << std::endl;
+
+    return 0;
+}