Added reproduction to Genome via Genome::operator() such that

child = mother(father), where mother is always the more fit genome. Crossover functions
to produce a child that is identical in structure to the more fit parent (mother), except
where structure (with the same innovation history) exists in bother parents. In this case
the genes are taken randomly from each. Need to finish test, but preliminary test was created.
Also adding a performance test of the fixed topology feed-forward network for comparison.

Author: Chris Sullivan

feedforward_perf.cc

@@ -0,0 +1,31 @@
+#include "Neural.hh"
+#include <chrono>
+#include <iostream>
+#include "Timer.hh"
+
+int main() {
+
+  auto nTrials = 100u;
+  double tperformance = 0.0;
+
+  // Time the network evaluation
+  for (auto i=0u; i < nTrials; i++)
+  {
+    Entendre::FeedForward network({10,20,10});
+
+    Timer tbuild([&tperformance](int elapsed) {
+        tperformance+=elapsed;
+      });
+
+    network.Feed({0.5,0.5,0.5,0.5,0.5,0.5,0.5,0.5,0.5,0.5});
+  }
+  std::cout << std:: endl
+            << "Average time to evaluate network: "
+            << tperformance/nTrials/1.0e6 << " ms\n"
+            << std::endl;
+  tperformance = 0.0;
+
+
+  return 0;
+
+}

libNeat/include/Genome.hh

@@ -4,6 +4,7 @@
 #include "Random.hh"
 
 namespace Constants {
+  const float Match = 0.5;
   const float PerturbWeight = 0.9;
   const float StepSize = 0.1;
   const float ResetWeightScale = 4.0;
@@ -13,12 +14,19 @@ struct Gene {
   bool enabled;
   unsigned long innovation_number;
   Connection link;
+  bool operator==(const Gene& other) {
+    return
+      (link.origin == other.link.origin) &&
+      (link.dest == other.link.dest) &&
+      (link.type == other.link.type);
+  }
 };
 
 class Genome : public uses_random_numbers {
 public:
+  Genome operator()(const Genome& father);
   operator NeuralNet() const;
-
+  void operator=(const Genome&);
   Genome& AddNode(NodeType type);
   Genome& AddGene(unsigned int origin, unsigned int dest, ConnectionType type,
                bool status, double weight);

libNeat/src/Genome.cc

@@ -14,10 +14,70 @@ Genome::operator NeuralNet() const {
   return net;
 }
 
+void Genome::operator=(const Genome& rhs) {
+  this->nodes = rhs.nodes;
+  this->genes = rhs.genes;
+  generator = rhs.generator;
+}
+
+// Genome mating
+Genome Genome::operator()(const Genome& father) {
+  // Implicit assumption: if there is a fitness difference
+  // then the mother must be the more fit genome. i.e.
+  // child = mother(father) s.t. fitness(mother) > fitness(father)
+  auto& mother = *this;
+  Genome child;
+
+  auto paternal = father.genes.begin();
+
+  // Mother is most fit, so we will not take
+  // any structure above and beyond what is in
+  // the mother. Thus, when we run out of mother
+  // genes to iterate over, we are done.
+  for (auto& maternal : mother.genes) {
+    const Gene* candidate = nullptr;
+
+    if (paternal != father.genes.end()){
+      if (maternal.innovation_number == paternal->innovation_number) {
+        candidate = (random()<Constants::Match) ? &maternal : &(*paternal);
+      }
+      else {
+        candidate = &maternal;
+      }
+      paternal++;
+    } else {
+      // no paternal genes left
+      candidate =  &maternal;
+    }
+
+    //if (!candidate) { continue; }
+
+    // does child already have a gene like the candidate?
+    bool unique = true;
+    for (auto& gene : child.genes) {
+      if (gene == *candidate) {
+        unique = false; break;
+      }
+    }
+
+    // add gene to child
+    if (unique) {
+      child.genes.push_back(*candidate);
+    }
+  }
+
+  // copy in nodes from more fit parent (mother)
+  child.nodes = mother.nodes;
+
+  // neshima
+  return child;
+}
+
 Genome& Genome::AddNode(NodeType type) {
   nodes.emplace_back(type);
   return *this;
 }
+
 Genome& Genome::AddGene(unsigned int origin, unsigned int dest, ConnectionType type,
              bool status, double weight) {
 

proto.cc

@@ -0,0 +1,23 @@
+#include <gtest/gtest.h>
+#include "Genome.hh"
+#include "NeuralNet.hh"
+#include "Timer.hh"
+
+TEST(Genome,CompareInnovation){
+    auto mother = Genome()
+        .AddNode(NodeType::Bias)
+        .AddNode(NodeType::Input)
+        .AddNode(NodeType::Hidden)
+        .AddNode(NodeType::Output)
+        .AddGene(0,3,ConnectionType::Normal,true,1.)
+        .AddGene(1,3,ConnectionType::Normal,true,1.)
+        .AddGene(1,2,ConnectionType::Normal,true,1.)
+        .AddGene(2,3,ConnectionType::Normal,true,1.);
+    mother.set_generator(std::make_shared<Uniform>(0,1));
+
+    auto father = mother;
+    mother.AddGene(3,2,ConnectionType::Recurrent,true,1.);
+    father.AddGene(0,2,ConnectionType::Normal,true,1.);
+
+    auto child = mother(father);
+}

tests/GenomeTests.cc

@@ -97,9 +97,8 @@ TEST(NeuralNet,EvaluateLargeNetwork){
         });
         auto net = NeuralNet(genome);
     }
-    std::cout << std:: endl
-              << "Average time to construct network: "
-              << tperformance/nTrials/1.0e6 << " ms\n"
+    std::cout << "                Average time to construct network: "
+              << tperformance/nTrials/1.0e6 << " ms"
               << std::endl;
     tperformance = 0.0;
 
@@ -116,9 +115,8 @@ TEST(NeuralNet,EvaluateLargeNetwork){
 
         auto result = net.evaluate({0.5,0.5,0.5,0.5,0.5,0.5,0.5,0.5,0.5,0.5});
     }
-    std::cout << std:: endl
-              << "Average time to evaluate network: "
-              << tperformance/nTrials/1.0e6 << " ms\n"
+    std::cout << "                Average time to evaluate network: "
+              << tperformance/nTrials/1.0e6 << " ms"
               << std::endl;