Upgrades and bug fixes:

- Replaced search for unused connection in MutateConnection with ReachabilityChecker, which can now return unused random connections.
  * This removed the need for MutateConnections to take in a NeuralNet reference as an argument, and so it was removed, and also removed
    from the Organism struct, since this was the primary motivation for placing this pointer in the organism.
- Added Population copy constructor, as well as move and copy assignment operators.
- ReachabilityChecker now required the number of inputs be specified on construction, and so a member was added to the Genome to keep
  track of the number of sensor nodes (input + bias) added into a genome.
- In both AddNode & AddConnection a static member was used for saving the last innovation number, this was meant to be global only within
  a genome, thus it was made a class member. This is also the case for node indexes in AddNode for producing innovation numbers for newly
  created nodes. This could probably be redesigned a bit.
- In Genome::MateWith, the very first action is now to add the sensor nodes of one of the parents into the child since they should be
  static and unchanging in the evolution. This then prevents any issues with reordering of nodes where the input nodes would possibly
  not be the first nodes in the node_genes vector. This is particularly important for the ReachabilityChecker which assumes the first
  num_inputs nodes are inputs.
- Fixed a bug in NeuralNet::would_make_loop which would not correctly mark a connection from a node to itself as recurrent. Now this
  check is made up front (if i==j return true).
- There was a bug with the culling_ratio in the species implementation where if the culling_ratio was 0.5 and there were only two species
  crossover could not proceed as there are two few specimen. Now if the number of specimen in a species is ==2 and the culling ratio is
  less than or equal to 0.5, the more fit of the two specimen is mutated and added to the output genome list.
- Added neat_xor test which after the above changes runs to completion, however is not finding a solution consistently or quickly enough.

Author: Chris Sullivan

libNeat/include/Genome.hh

@@ -29,6 +29,7 @@ class ReachabilityChecker;
 class Genome : public uses_random_numbers,
                public requires<Probabilities> {
 public:
+  Genome();
   operator NeuralNet() const;
   Genome operator=(const Genome&);
   //Genome& operator=(Genome);
@@ -39,8 +40,7 @@ public:
   Genome  MateWith(const Genome& father);
   Genome  MateWith(Genome* father);
   void    Mutate();
-  void    Mutate(const NeuralNet&);
-  void    MutateConnection(const NeuralNet&);
+  void    MutateConnection();
   void    MutateNode();
   void    MutateWeights();
   void    MutateReEnableGene();
@@ -56,7 +56,15 @@ private:
 
 
 private:
+  size_t num_inputs;
   std::vector<NodeGene> node_genes;
   std::unordered_map<unsigned long,unsigned int> node_lookup;
   insertion_ordered_map<unsigned long, ConnectionGene> connection_genes;
+
+  // innovation record keeping
+  unsigned long last_conn_innov;
+  unsigned long last_node_innov;
+  unsigned long idxinput;
+  unsigned long idxoutput;
+  unsigned long idxhidden;
 };

libNeat/include/Population.hh

@@ -16,6 +16,9 @@ public:
   Population(std::vector<Genome> population,
              std::shared_ptr<RNG>,std::shared_ptr<Probabilities>);
 
+  Population(const Population&);
+
+  Population& operator=(Population&&);
   /// Evaluate the fitness function for each neural net.
   template<class Callable>
   void Evaluate(Callable&& fitness) {
@@ -25,7 +28,6 @@ public:
       Organism org = {};
       org.fitness = fitness(net);
       org.genome = &population[n++];
-      org.net = &net;
       organisms.push_back(org);
     }
   }
@@ -43,6 +45,8 @@ public:
    */
   Population Reproduce();
 
+  Population operator=(const Population& rhs);
+
 private:
   struct Organism {
     // A proxy class for class Genome, containing its
@@ -52,7 +56,6 @@ private:
     float fitness;
     float adj_fitness;
     Genome* genome;
-    NeuralNet* net;
   };
 
   void build_networks();

libNeat/include/ReachabilityChecker.hh

@@ -1,36 +1,90 @@
 #pragma once
-#include <vector>
+
 #include <cstring>
+#include <utility>
+#include <vector>
+
+class RNG;
 
 class ReachabilityChecker {
 public:
-  ReachabilityChecker(size_t num_nodes);
+  /// Constructs the reachability checker
+  /*
+    num_nodes is the total number of nodes.
+    num_inputs is the number of input nodes.
+
+    Here, an input node is defined as any node that cannot be the
+    destination of a connection.
+    The input nodes are at indices [0, num_inputs).
+   */
+  ReachabilityChecker(size_t num_nodes, size_t num_inputs = 0);
+
+  /// Adds a connection
+  /*
+    origin is the index of the origin-node
+    destination is the index of the destination-node.
 
+    Assumes that destination >= num_inputs.
+
+    The connection added is a normal connection,
+      unless adding such a connection would cause the normal connections to contain a loop.
+    In that case, the connection added is recurrent.
+   */
   void AddConnection(size_t origin, size_t destination);
 
+  /// Checks whether a given connection has been defined
   bool HasConnection(size_t origin, size_t destination) const {
     return at(origin,destination).has_any_connection;
   }
+
+  /// Checks whether a given connection has been defined, and is normal
   bool HasNormalConnection(size_t origin, size_t destination) const {
     return at(origin,destination).has_normal_connection;
   }
+
+  /// Checks whether a given connection has been defined, and is recurrent
   bool HasRecurrentConnection(size_t origin, size_t destination) const {
     return at(origin,destination).has_recurrent_connection;
   }
 
+  /// Return true if a path from origin to destination exists using only normal connections.
   bool IsReachableNormal(size_t origin, size_t destination) const {
     return at(origin,destination).reachable_normal;
   }
+
+  /// Return true if a path from origin to destination exists using any connections.
   bool IsReachableEither(size_t origin, size_t destination) const {
     return at(origin,destination).reachable_either;
   }
 
-  // bool IsFullyConnected() const {
-  // }
-  // std::pair<size_t,size_t> AddRandomRecurrent() {
-  // }
-  // std::pair<size_t,size_t> AddRandomNormal() {
-  // }
+  /// Returns true if no additional connections can be added.
+  bool IsFullyConnected() const {
+    return (num_possible_normal_connections == 0 &&
+            num_possible_recurrent_connections == 0);
+  }
+
+  /// Returns the number of different normal connections that could be added.
+  size_t NumPossibleNormalConnections() const {
+    return num_possible_normal_connections;
+  }
+
+  /// Returns the number of different recurrent connections that could be added.
+  size_t NumPossibleRecurrentConnections() const {
+    return num_possible_recurrent_connections;
+  }
+
+  /// Returns a randomly selected normal connection to add.
+  /**
+     If no such connection exists, returns (-1,-1).
+   */
+  std::pair<int,int> RandomNormalConnection(RNG& rng);
+
+  /// Returns a randomly selected recurrent connection to add.
+  /**
+     If no such connection exists, returns (-1,-1).
+   */
+  std::pair<int,int> RandomRecurrentConnection(RNG& rng);
+
 
 
 
@@ -49,6 +103,10 @@ private:
   };
 
   size_t num_nodes;
+  size_t num_inputs;
+  size_t num_possible_normal_connections;
+  size_t num_possible_recurrent_connections;
+
   std::vector<MatrixElement> mat;
 
   MatrixElement& at(size_t i, size_t j) {
@@ -60,4 +118,14 @@ private:
 
   void fill_normal_reachable(size_t origin, size_t destination);
   void fill_either_reachable(size_t origin, size_t destination);
+
+  bool could_add_normal(size_t origin, size_t destination) {
+    return (!at(origin,destination).has_any_connection &&
+            !at(destination, origin).reachable_normal);
+  }
+
+  bool could_add_recurrent(size_t origin, size_t destination) {
+    return (!at(origin,destination).has_any_connection &&
+            at(destination, origin).reachable_normal);
+  }
 };

libNeat/include/Requirements.hh

@@ -9,7 +9,7 @@ public:
   std::shared_ptr<T> required() const { return required_; }
   void required(const std::shared_ptr<T>& req) { required_ = req; }
 
-private:
+protected:
   std::shared_ptr<T> required_;
 };