StatsManagers can be passed as template arguments

evo/PopulationIterator.h

@@ -0,0 +1,82 @@
+#ifndef EMP_EVO_POP_ITER_H
+#define EMP_EVO_POP_ITER_H
+
+//#include "World.h"
+#include "PopulationManager.h"
+
+namespace emp{
+namespace evo{
+
+template <typename POP_MANAGER>
+class PopulationIterator{
+private:
+  using ORG = typename POP_MANAGER::value_type;
+  POP_MANAGER * pop;
+  int curr = 0;
+  int size;
+
+public:
+  //typedef  iterator;
+  //typedef ptrdiff_t difference_type;
+  //typedef size_t size_type;
+  //typedef T value_type;
+  //typedef T * pointer;
+  //typedef T & reference;
+
+  PopulationIterator(POP_MANAGER * w, int ind = 0){
+    pop  = w;
+    curr = ind;
+    size = pop->size();
+    while ((curr < size) && (((*pop)[curr]) == nullptr)){
+      ++curr;
+    }
+  }
+
+  PopulationIterator(PopulationIterator * w){
+    pop  = w->pop;
+    curr = w->curr;
+    size = w->size;
+    while (curr < size && (((*pop)[curr]) == nullptr)) {
+      ++curr;
+    }
+  }
+
+  PopulationIterator<POP_MANAGER> & operator++() {
+    ++curr;
+    while (curr < size && (((*pop)[curr]) == nullptr)) {
+      ++curr;
+    }
+    return *this;
+  }
+
+  PopulationIterator<POP_MANAGER> & operator--() {
+    --curr;
+    while (curr < size && (((*pop)[curr]) == nullptr)) {
+      --curr;
+    }
+    return *this;
+  }
+
+  bool operator==(const PopulationIterator<POP_MANAGER>& rhs){
+    return curr == rhs.curr;
+  }
+
+  bool operator!=(const PopulationIterator<POP_MANAGER>& rhs){
+    return curr != rhs.curr;
+  }
+
+  ORG & operator*() {return (*pop)[curr];}
+
+  PopulationIterator<POP_MANAGER> begin() {
+    return PopulationIterator<ORG>(pop, 0);
+  }
+
+  PopulationIterator<POP_MANAGER> end() {
+    return PopulationIterator<POP_MANAGER>(pop, size);
+  }
+
+
+};
+}
+}
+#endif

evo/PopulationManager.h

@@ -13,10 +13,13 @@
 #define EMP_EVO_POPULATION_MANAGER_H
 
 #include "../tools/random_utils.h"
+#include "PopulationIterator.h"
 
 namespace emp {
 namespace evo {
 
+  template <typename POP_MANAGER> class PopulationIterator;
+
   template <typename ORG=int>
   class PopulationManager_Base {
   protected:
@@ -32,9 +35,15 @@ namespace evo {
     // Allow this and derived classes to be identified as a population manager.
     static constexpr bool emp_is_population_manager = true;
     static constexpr bool emp_has_separate_generations = false;
+    using value_type = ORG*;
+
+    friend class PopulationIterator<PopulationManager_Base<ORG> >;
+    using iterator = PopulationIterator<PopulationManager_Base<ORG> >;
 
     ptr_t & operator[](int i) { return pop[i]; }
     const ptr_t operator[](int i) const { return pop[i]; }
+    iterator begin(){return iterator(this, 0);}
+    iterator end(){return iterator(this, pop.size());}
 
     uint32_t size() const { return pop.size(); }
     void resize(int new_size) { pop.resize(new_size); }

evo/Stats.h

@@ -20,9 +20,12 @@
 namespace emp{
 namespace evo{
 
+
+
   //Calculates Shannon Entropy of the members of the container passed
-  template <typename C, class = typename C::value_type >
-  double ShannonDiversity(C elements) {
+  template <typename C>
+  typename std::enable_if<!std::is_pointer<typename C::value_type>::value, double>::type
+  ShannonDiversity(C & elements) {
 
     //Count number of each value present
     std::map<typename C::value_type, int> counts;
@@ -42,23 +45,24 @@ namespace evo{
     }
 
     return -1 * result;
-  }
+}
 
   //Calculates Shannon Entropy of the members of a world
-  template <typename ORG, typename... MANAGERS>
-  double ShannonDiversity(emp::evo::World<ORG, MANAGERS...> & elements) {
+  template <typename C>
+  typename std::enable_if<std::is_pointer<typename C::value_type>::value, double>::type
+  ShannonDiversity(C & elements) {
 
+    using pointed_at = typename std::remove_pointer<typename C::value_type>::type;
     //Count number of each value present
-    std::map<ORG, int> counts;
+    std::map<pointed_at, int> counts;
     for (auto element : elements) {
-      if (counts.find(element) != counts.end()) {
-        counts[element]++;
+      if (counts.find(*element) != counts.end()) {
+        counts[*element]++;
       } else {
-        counts[element] = 1;
+        counts[*element] = 1;
       }
 
     }
-
     //Shannon entropy calculation
     double result = 0;
     for (auto element : counts) {
@@ -67,7 +71,7 @@ namespace evo{
     }
 
     return -1 * result;
-  }
+}
 
   //Calculates number of unique elements in the container passed
   template <typename C>
@@ -78,19 +82,19 @@ namespace evo{
     return unique_elements.size();
   }
 
-  template <typename ORG, typename C, class = typename C::value_type >
-  double MaxFitness(std::function<double(ORG * org)> fit_fun, C orgs){
-    double fittest = fit_fun(&orgs[0]);
+  template <typename C, class = typename C::value_type >
+  double MaxFitness(std::function<double(typename C::value_type org)> fit_fun, C orgs){
+    double fittest = fit_fun(orgs[0]);
     for (auto org : orgs){
-      double fitness = fit_fun(&org);
+      double fitness = fit_fun(org);
       if (fitness > fittest){
         fittest = fitness;
       }
     }
     return fittest;
   }
 
-  template <typename ORG, typename... MANAGERS>
+/*  template <typename ORG, typename... MANAGERS>
   double MaxFitness(std::function<double(ORG * org)> fit_fun, World<ORG, MANAGERS...> & orgs){
     double fittest = fit_fun(&(*(orgs.begin())));
     for (auto org : orgs){
@@ -101,7 +105,20 @@ namespace evo{
     }
     return fittest;
   }
+*/
 
+template <typename C, class = typename C::value_type>
+  double AverageFitness(std::function<double(typename C::value_type org)> fit_fun, C & orgs){
+    double cumulative_fitness = 0;
+    double num_orgs = 0;
+    for (auto org : orgs){
+        ++num_orgs;
+        cumulative_fitness += fit_fun(org);
+    }
+    return (cumulative_fitness / num_orgs);
+  }
+
+/*
 template <typename ORG, typename... MANAGERS>
   double AverageFitness(std::function<double(ORG * org)> fit_fun, World<ORG, MANAGERS...> & orgs){
     double cumulative_fitness = 0;
@@ -112,7 +129,7 @@ template <typename ORG, typename... MANAGERS>
     }
     return (cumulative_fitness / num_orgs);
   }
-
+*/
 }
 }