From be19562147e9c55326ec9e139ec7221be5e2a5cc Mon Sep 17 00:00:00 2001
From: Johann Dreo <johann.dreo@thalesgroup.com>
Date: Fri, 3 Sep 2010 15:55:28 +0200
Subject: [PATCH 1/2] Patch from Karima.Boufaras@inria.fr: compilation wth
 CUDACC

---
 eo/src/PO.h              |  6 +++-
 eo/src/eoPop.h           | 65 ++++++++++++++++++++++++++++------------
 eo/src/eoScalarFitness.h |  6 ++++
 3 files changed, 57 insertions(+), 20 deletions(-)

diff --git a/eo/src/PO.h b/eo/src/PO.h
index 2cac3d86..1b15ef03 100644
--- a/eo/src/PO.h
+++ b/eo/src/PO.h
@@ -41,7 +41,11 @@ template < class F > class PO:public EO < F >
 
 public:
 
-    typedef typename PO < F >::Fitness Fitness;
+	#if defined(__CUDACC__)
+		typedef typename EO < F >::Fitness Fitness;
+	#else
+		typedef typename PO<F>::Fitness Fitness;
+	#endif
 
     /** Default constructor.
         Fitness must have a ctor which takes 0 as a value. Best fitness mush also have the same constructor.
diff --git a/eo/src/eoPop.h b/eo/src/eoPop.h
index 2b1a08f6..99927e25 100644
--- a/eo/src/eoPop.h
+++ b/eo/src/eoPop.h
@@ -53,16 +53,20 @@
 template<class EOT>
 class eoPop: public std::vector<EOT>, public eoObject, public eoPersistent
 {
+public:
+     
+    using std::vector<EOT>::size;
+    using std::vector<EOT>::resize;
+    using std::vector<EOT>::operator[];
+    using std::vector<EOT>::begin;
+    using std::vector<EOT>::end;
+     
+    typedef typename EOT::Fitness Fitness;
+#if defined(__CUDACC__)
+    typedef typename std::vector<EOT>::iterator iterator;
+    typedef typename std::vector<EOT>::const_iterator const_iterator;
+#endif
 
- public:
-     
-     using std::vector<EOT>::size;
-     using std::vector<EOT>::resize;
-     using std::vector<EOT>::operator[];
-     using std::vector<EOT>::begin;
-     using std::vector<EOT>::end;
-     
-     typedef typename EOT::Fitness Fitness;
 	/** Default ctor. Creates empty pop
 	*/
 	eoPop()	  : std::vector<EOT>(), eoObject(), eoPersistent() {};
@@ -177,30 +181,48 @@ class eoPop: public std::vector<EOT>, public eoObject, public eoPersistent
   }
 
   /** returns an iterator to the best individual DOES NOT MOVE ANYBODY */
-  typename eoPop<EOT>::iterator it_best_element() 
+  eoPop<EOT>::iterator it_best_element()
   {
-    typename eoPop<EOT>::iterator it = std::max_element(begin(), end());
+#if defined(__CUDACC__)
+	eoPop<EOT>:: iterator it = std::max_element(begin(), end());
+#else
+	typename eoPop<EOT>::iterator it_best_element() {
+	typename eoPop<EOT>::iterator it = std::max_element(begin(), end());
+#endif
     return it;
   }
 
   /** returns an iterator to the best individual DOES NOT MOVE ANYBODY */
   const EOT & best_element() const
   {
-    typename eoPop<EOT>::const_iterator it = std::max_element(begin(), end());
+#if defined(__CUDACC__)
+    eoPop<EOT>::const_iterator it = std::max_element(begin(), end());
+#else
+	typename eoPop<EOT>::const_iterator it = std::max_element(begin(), end());
+#endif
     return (*it);
   }
 
   /** returns a const reference to the worse individual DOES NOT MOVE ANYBODY */
   const EOT & worse_element() const
   {
-    typename eoPop<EOT>::const_iterator it = std::min_element(begin(), end());
+#if defined(__CUDACC__)
+    eoPop<EOT>::const_iterator it = std::min_element(begin(), end());
+#else
+	typename eoPop<EOT>::const_iterator it = std::min_element(begin(), end());
+#endif
     return (*it);
   }
 
   /** returns an iterator to the worse individual DOES NOT MOVE ANYBODY */
-  typename eoPop<EOT>::iterator it_worse_element()
-  {
-    typename eoPop<EOT>::iterator it = std::min_element(begin(), end());
+	eoPop<EOT>::iterator it_worse_element()
+	{
+#if defined(__CUDACC__)
+      eoPop<EOT>::iterator it = std::min_element(begin(), end());
+#else
+	  typename eoPop<EOT>::iterator it_worse_element() {
+	  typename eoPop<EOT>::iterator it = std::min_element(begin(), end());
+#endif
     return it;
   }
 
@@ -208,9 +230,14 @@ class eoPop: public std::vector<EOT>, public eoObject, public eoPersistent
   slightly faster algorithm than sort to find all individuals that are better
   than the nth individual. INDIVIDUALS ARE MOVED AROUND in the pop.
   */
-  typename eoPop<EOT>::iterator nth_element(int nth)
-  {
-      typename eoPop<EOT>::iterator it = begin() + nth;
+	eoPop<EOT>::iterator nth_element(int nth)
+	{
+#if defined(__CUDACC__)
+	  eoPop<EOT>::iterator it = begin() + nth;
+#else
+	  typename eoPop<EOT>::iterator nth_element(int nth) {
+	  typename eoPop<EOT>::iterator it = begin() + nth;
+#endif
       std::nth_element(begin(), it, end(), std::greater<EOT>());
       return it;
   }
diff --git a/eo/src/eoScalarFitness.h b/eo/src/eoScalarFitness.h
index 59c68f9b..26bad273 100644
--- a/eo/src/eoScalarFitness.h
+++ b/eo/src/eoScalarFitness.h
@@ -82,8 +82,14 @@ and minimizing fitness compares with greater. This because we want ordinary
 fitness values (doubles) to be equivalent with Maximizing Fitness, and
 comparing with less is the default behaviour.
 */
+
+#if defined(__CUDACC__)
+typedef eoScalarFitness<float, std::less<float> >    eoMaximizingFitness;
+typedef eoScalarFitness<float, std::greater<float> > eoMinimizingFitness;
+#else
 typedef eoScalarFitness<double, std::less<double> >    eoMaximizingFitness;
 typedef eoScalarFitness<double, std::greater<double> > eoMinimizingFitness;
+#endif
 
 template <class F, class Cmp>
 std::ostream& operator<<(std::ostream& os, const eoScalarFitness<F, Cmp>& f)

From 66b4dfd54b6d92abf937b4f885e95f7fd0e14f17 Mon Sep 17 00:00:00 2001
From: Johann Dreo <johann.dreo@thalesgroup.com>
Date: Mon, 20 Sep 2010 13:35:51 +0200
Subject: [PATCH 2/2] typofix declaration types in macro

---
 eo/src/eoPop.h | 24 +++++++++++++-----------
 1 file changed, 13 insertions(+), 11 deletions(-)

diff --git a/eo/src/eoPop.h b/eo/src/eoPop.h
index 99927e25..b2d58fac 100644
--- a/eo/src/eoPop.h
+++ b/eo/src/eoPop.h
@@ -181,9 +181,9 @@ public:
   }
 
   /** returns an iterator to the best individual DOES NOT MOVE ANYBODY */
+#if defined(__CUDACC__)
   eoPop<EOT>::iterator it_best_element()
   {
-#if defined(__CUDACC__)
 	eoPop<EOT>:: iterator it = std::max_element(begin(), end());
 #else
 	typename eoPop<EOT>::iterator it_best_element() {
@@ -207,20 +207,21 @@ public:
   const EOT & worse_element() const
   {
 #if defined(__CUDACC__)
-    eoPop<EOT>::const_iterator it = std::min_element(begin(), end());
+      eoPop<EOT>::const_iterator it = std::min_element(begin(), end());
 #else
-	typename eoPop<EOT>::const_iterator it = std::min_element(begin(), end());
+	  typename eoPop<EOT>::const_iterator it = std::min_element(begin(), end());
 #endif
     return (*it);
   }
 
   /** returns an iterator to the worse individual DOES NOT MOVE ANYBODY */
-	eoPop<EOT>::iterator it_worse_element()
-	{
 #if defined(__CUDACC__)
+  eoPop<EOT>::iterator it_worse_element()
+  {
       eoPop<EOT>::iterator it = std::min_element(begin(), end());
 #else
-	  typename eoPop<EOT>::iterator it_worse_element() {
+  typename eoPop<EOT>::iterator it_worse_element() 
+  {
 	  typename eoPop<EOT>::iterator it = std::min_element(begin(), end());
 #endif
     return it;
@@ -230,12 +231,13 @@ public:
   slightly faster algorithm than sort to find all individuals that are better
   than the nth individual. INDIVIDUALS ARE MOVED AROUND in the pop.
   */
-	eoPop<EOT>::iterator nth_element(int nth)
-	{
-#if defined(__CUDACC__)
-	  eoPop<EOT>::iterator it = begin() + nth;
+#if defined(__CUDACC__)  
+  eoPop<EOT>::iterator nth_element(int nth)
+  {
+      eoPop<EOT>::iterator it = begin() + nth;
 #else
-	  typename eoPop<EOT>::iterator nth_element(int nth) {
+  typename eoPop<EOT>::iterator nth_element(int nth) 
+  {
 	  typename eoPop<EOT>::iterator it = begin() + nth;
 #endif
       std::nth_element(begin(), it, end(), std::greater<EOT>());