Stats Manager headers + assorted cleanup

evo/LineageTracker.h

@@ -28,7 +28,7 @@ namespace evo{
   // they belonged to, and which organisms were the parents of which
   template <typename POP_MANAGER = PopulationManager_Base<int> >
   class LineageTracker {
-  private:
+  protected:
     using org_ptr = typename POP_MANAGER::value_type;
     using ORG = typename std::remove_pointer<org_ptr>::type;
     static constexpr bool separate_generations = POP_MANAGER::emp_has_separate_generations;
@@ -41,7 +41,8 @@ namespace evo{
     int next_parent_id = -1;
     int next_org_id = 1;
     emp::vector<int> generation_since_update;
-    emp::vector<int> prev_generation;
+    emp::vector<int> new_generation;
+    bool inject;
 
     LineageTracker(){;}
 
@@ -91,41 +92,47 @@ namespace evo{
     //Put newly born organism into the lineage tracker
 
     void Update(int i) {
-      prev_generation = generation_since_update;
       if (separate_generations) {
         //TODO: This isn't sufficient - need to add signals for any
         //population change event
-        generation_since_update.resize(0);
+        generation_since_update = new_generation;
+        new_generation.resize(0);
       }
     }
 
     void TrackOffspring(org_ptr org) {
       next_org_id = this->AddOrganism(*org, next_parent_id);
+      inject = false;
     }
 
     //Put newly injected organism into the lineage tracker
     void TrackInjectedOffspring(org_ptr org) {
       next_org_id = this->AddOrganism(*org, 0);
+      inject = true;
     }
 
     //Keep track of location of all orgs in the population so that
     //we can translate their ids from the World to ids within the lineage
     //tracker
     void TrackPlacement(int pos) {
-      if (pos >= generation_since_update.size()) {
-        generation_since_update.resize(pos+1);
+      if (separate_generations && !inject){
+        if (pos >= new_generation.size()) {
+          new_generation.resize(pos+1);
+        }
+        new_generation[pos] = next_org_id;
+
+      } else {
+        if (pos >= generation_since_update.size()) {
+          generation_since_update.resize(pos+1);
+        }
+        generation_since_update[pos] = next_org_id;
       }
-      generation_since_update[pos] = next_org_id;
     }
 
     //Record the org that's about to have an offspring, so we can know
     //who the parent of the next org is.
     void RecordParent(int id) {
-      if (separate_generations){
-        next_parent_id = prev_generation[id];
-      } else {
-        next_parent_id = generation_since_update[id];
-      }
+      next_parent_id = generation_since_update[id];
     }
 
     // Add an organism to the tracker - org is the genome of the organism

evo/OEE.h

@@ -39,11 +39,10 @@ namespace evo{
     using ORG = typename std::remove_pointer<org_ptr>::type;
     using skeleton_type = emp::vector<int>;
     static constexpr bool separate_generations = POP_MANAGER::emp_has_separate_generations;
-    //TODO: Make this use existing lineage tracker if there is one
 
     std::set<skeleton_type > novel;
 
-    int generations = 50; //How far back do we look for persistance?
+    int generations = OeeConfig.GENERATIONS(); //How far back do we look for persistance?
 
     // Historical generations needed to count stats. We only need these in
     // proportion to resolution.
@@ -74,6 +73,8 @@ namespace evo{
       emp_assert(generations % resolution == 0 &&
                 "ERROR: Generations required for persistance must be a multiple of resolution.",
                 resolution, generations);
+
+      OeeConfig.Read("OEE_stats.cfg");
       generations = OeeConfig.GENERATIONS();
       OeeConfig.Write("OEE_stats.cfg");
 
@@ -87,7 +88,6 @@ namespace evo{
       w->OnUpdate(UpdateFun);
       lineage = &(w->lineageM);
 
-      //TODO: Figure out how to make this work automatically
       output_location << "update" << delimiter << "change" << delimiter
             << "novelty" << delimiter << "ecology" << delimiter
             << "complexity" << std::endl;

evo/StatsManager.h

@@ -104,23 +104,26 @@ namespace evo{
     using StatsManager_Base<POP_MANAGER>::resolution;
     using StatsManager_Base<POP_MANAGER>::output_location;
     using StatsManager_Base<POP_MANAGER>::delimiter;
+    bool header_printed = false;
+    std::string header = "update";
 
   public:
     using StatsManager_Base<POP_MANAGER>::emp_is_stats_manager;
     fit_fun_type fit_fun;
 
+    //Constructor for creating this as a stand-alone object
     template <typename WORLD>
     StatsManager_FunctionsOnUpdate(WORLD * w,
                                    std::string location = "stats.csv") :
                                    StatsManager_Base<decltype(w->popM)>(location){
       Setup(w);
     }
 
+    //Constructor for use by World object
     StatsManager_FunctionsOnUpdate(std::string location = "stats.csv") :
                                    StatsManager_Base<POP_MANAGER>(location){;}
 
     //The fitness function for calculating fitness related stats
-
     template <typename WORLD>
     void Setup(WORLD * w){
       pop = &(w->PopM);
@@ -134,17 +137,31 @@ namespace evo{
 
     //Function for adding functions that calculate stats to the
     //set to be calculated
-    void AddFunction(std::function<double(POP_MANAGER*)> func) {
+    void AddFunction(std::function<double(POP_MANAGER*)> func, std::string label) {
       world_stats.Add(func);
+      if (header_printed){
+        NotifyWarning("Function added to stats manager after initialization.");
+      } else {
+        header += delimiter + label;
+      }
     }
 
     //Version for functions that require a fitness function
-    void AddFunction(std::function<double(fit_fun_type, POP_MANAGER*)> func) {
+    void AddFunction(std::function<double(fit_fun_type, POP_MANAGER*)> func, std::string label) {
       fitness_stats.Add(func);
+      if (header_printed){
+        NotifyWarning("Function added to stats manager after initialization.");
+      } else {
+        header += delimiter + label;
+      }
     }
 
     //If this update matches the resolution, calculate and record all the stats
     void Update(int update) {
+      if (!header_printed) {
+          output_location << header << std::endl;
+          header_printed = true;
+      }
 
       if (update % resolution == 0){
 
@@ -186,24 +203,23 @@ namespace evo{
       using StatsManager_Base<POP_MANAGER>::emp_is_stats_manager;
       using StatsManager_FunctionsOnUpdate<POP_MANAGER>::SetDefaultFitnessFun;
 
+      //Constructor for use as a stand-alone object
       template <typename WORLD>
       StatsManager_DefaultStats(WORLD * w, std::string location = "averages.csv")
        : StatsManager_FunctionsOnUpdate<decltype(w->popM)>(w, location){
-
         Setup(w);
-        //Print header
-        output_location << "update, shannon_diversity, max_fitness, avg_fitness" << std::endl;
       }
 
+      //Constructor for use as a template parameter for the world
       StatsManager_DefaultStats(std::string location = "averages.csv")
-       : StatsManager_FunctionsOnUpdate<POP_MANAGER>(location){
-        //Print header
-        output_location << "update, shannon_diversity, max_fitness, avg_fitness" << std::endl;
-      }
+       : StatsManager_FunctionsOnUpdate<POP_MANAGER>(location){;}
 
+      //Add appropriate functions to function sets
       template <typename WORLD>
       void Setup(WORLD * w){
         pop = &(w->popM);
+
+        //Create std::function object for all of the stats
         std::function<double(POP_MANAGER*)> diversity = [](POP_MANAGER * pop){
             return ShannonEntropy(*pop);
         };
@@ -214,14 +230,15 @@ namespace evo{
             return AverageFunctionReturn(fit_func, *pop);
         };
 
-        AddFunction(diversity);
-        AddFunction(max_fitness);
-        AddFunction(avg_fitness);
-
         std::function<void(int)> UpdateFun = [&] (int ud){
             Update(ud);
         };
 
+        //Add functions to manager
+        AddFunction(diversity, "shannon_diversity");
+        AddFunction(max_fitness, "max_fitness");
+        AddFunction(avg_fitness, "avg_fitness");
+
         w->OnUpdate(UpdateFun);
       }
 

evo/World.h

@@ -136,7 +136,6 @@ namespace evo {
   EMP_SETUP_TYPE_SELECTOR(SelectOrgManager, emp_is_organism_manager);
   EMP_SETUP_TYPE_SELECTOR(SelectStatsManager, emp_is_stats_manager);
   EMP_SETUP_TYPE_SELECTOR(SelectLineageManager, emp_is_lineage_manager);
-  EMP_SETUP_TYPE_SELECTOR(NeedsLineageManager, lineage);
 
   template <typename POP_MANAGER> class PopulationIterator;
 
@@ -153,8 +152,6 @@ namespace evo {
     EMP_CHOOSE_MEMBER_TYPE(DefaultLineage, lineage_type, LineageNull, decltype(statsM));
     AdaptTemplate<typename SelectLineageManager<MANAGERS...,DefaultLineage>::type, decltype(popM)> lineageM;
 
-    //emp::evo::OEEStatsManager<decltype(popM)> statsM;
-
     Random * random_ptr;
     bool random_owner;
     int update = 0;
@@ -333,7 +330,6 @@ namespace evo {
     void EliteSelect(std::function<double(ORG*)> fit_fun, int e_count=1, int copy_count=1) {
       emp_assert(fit_fun);
       emp_assert(e_count > 0 && e_count <= (int) popM.size());
-
       // Load the population into a multimap, sorted by fitness.
       std::multimap<double, int> fit_map;
       for (int i = 0; i < (int) popM.size(); i++) {

tools/stats.h

@@ -124,6 +124,28 @@ namespace evo{
     return (cumulative_value / count);
   }
 
+  template <typename C, typename RET_TYPE>
+  emp::vector<RET_TYPE> RunFunctionOnContainer(std::function<RET_TYPE(typename C::value_type)> fun, C & elements) {
+      emp::vector<RET_TYPE> results;
+      for (auto element : elements){
+          results.push_back(fun(element));
+      }
+      return results;
+  }
+
+  //This variant is actually super confusing because the value_type of world
+  //and population managers are pointers whereas the type that they're templated
+  //on is not. Also because the insert method for emp::vectors doesn't take an
+  //additional argument?
+  /*template <template <typename> class C, typename RET_TYPE, typename T>
+  C<RET_TYPE> RunFunctionOnContainer(std::function<RET_TYPE(T)> fun, C<T> & elements) {
+      C<RET_TYPE> results;
+      for (auto element : elements){
+          results.insert(fun(element), results.back());
+      }
+      return results;
+  }*/
+
 }
 }