wallace 0.0.0

data/Gemfile

@@ -0,0 +1,14 @@
+source 'http://rubygems.org'
+
+gem 'peach'
+
+# GraphViz - Great for Trees, Graph and Network visualisation.
+#gem 'ruby-graphviz'
+#gem 'win32-open3'
+
+group :development do
+	gem 'jeweler', '~> 1.8.7'
+  gem 'rake'
+  gem 'rdoc'
+  gem 'bundler'
+end

data/README.md

@@ -0,0 +1,12 @@
+**Wallace.rb**
+==========
+
+A highly expressive and modular evolutionary toolkit for performing genetic algorithms, genetic programming, grammatical evolution and meta-evolution in Ruby.
+
+**Tested with:**
+* Ruby >= 1.9.1
+* JRuby >= 1.7.8
+
+**Tested platforms:**
+* Windows 7 (x64)
+* Ubuntu 13.10 (x64)

data/Rakefile

@@ -0,0 +1,52 @@
+# Load all dependencies.
+require 'rubygems'
+require 'bundler'
+require 'rake'
+require 'rake/testtask'
+require 'rdoc/task'
+require 'jeweler'
+
+begin
+  Bundler.setup(:default, :development)
+rescue Bundler::BundlerError => e
+  $stderr.puts e.message
+  $stderr.puts "Run `bundle install` to install missing gems"
+  exit e.status_code
+end
+
+# Gem Specification.
+Jeweler::Tasks.new do |gem|
+  gem.name = "wallace"
+  gem.homepage = "http://github.com/ChrisTimperley/Wallace.rb"
+  gem.license = "MIT"
+  gem.summary = "A powerful, flexible and modular toolkit for running Evolutionary Algorithms in Ruby"
+  gem.description = <<-EOF
+    Wallace is a powerful, flexible and modular toolkit for running Evolutionary Algorithms in Ruby.
+    Out of the box it provides support for steady-state EAs, genetic algorithms, genetic programming,
+    grammatical evolution and other types of EAs.
+  EOF
+  gem.email = "christimperley@gmail.com"
+  gem.author = "Chris Timperley"
+  gem.add_dependency "peach", "~> 0.5.1"
+end
+
+# Gem Management.
+Jeweler::RubygemsDotOrgTasks.new
+
+# Unit Testing.
+Rake::TestTask.new(:test) do |test|
+  test.libs << 'lib' << 'test'
+  test.pattern = 'test/**/test_*.rb'
+  test.verbose = true
+end
+
+# Documentation.
+task :default => :test
+Rake::RDocTask.new do |rdoc|
+  version = File.exist?('VERSION') ? File.read('VERSION') : ""
+
+  rdoc.rdoc_dir = 'rdoc'
+  rdoc.title = "wallace #{version}"
+  rdoc.rdoc_files.include('README*')
+  rdoc.rdoc_files.include('lib/**/*.rb')
+end

data/VERSION

@@ -0,0 +1 @@
+0.0.0

data/lib/analysers/fitness_distribution_analyser.rb

@@ -0,0 +1,28 @@
+class Wallace::Analysers::FitnessDistributionAnalyser < Wallace::Analyser
+
+  def initialize
+
+  end
+
+  def after_generation(state)
+
+  end
+
+  protected
+
+  # Calculates the distribution of fitness values at the current evolution state.
+  #
+  # *Parameters:*
+  # * state, the current state of the evolution.
+  def calculate_distribution(state)
+    stats = {}
+    stats[:max] = state.population.fitness_max
+    stats[:min] = state.population.fitness_min
+    stats[:lq], stats[:median], stats[:uq] = state.population.fitness_quartiles
+    stats[:mean] = state.population.fitness_mean
+    stats[:std] = 
+    stats[:var] = 
+    return stats
+  end
+
+end

data/lib/analysers/init.rb

@@ -0,0 +1 @@
+module Wallace::Analysers; end

data/lib/core/analyser.rb

@@ -0,0 +1,63 @@
+# Analysers are used to analyse the current state of the evolution at given stages.
+# These objects may be used to gather data, calculate statistics and log information
+# during the evolution.
+#
+# Analysers may harness the outputs of attached analysers to supplement their input data.
+# This ability can be exploited to perform multi-stage post-processing and to efficiently
+# record information.
+class Wallace::Analyser
+
+  attr_reader :inputs
+
+  # Constructs a new analyser.
+  #
+  # *Parameters:*
+  # * inputs, the input analysers which feed data into this analyser.
+  def initialize(inputs)
+    @inputs = inputs
+  end
+
+  # Runs this analyser at a given stage in the evolution.
+  #
+  # Executes the input analysers to gather the input data which is then
+  # fed into the appropriate stage handler of this analyser.
+  # 
+  # *Parameters:*
+  # * stage, the current stage in the evolution.
+  # * state, the current state of the evolution.
+  #
+  # *Returns:*
+  # Output data for processing by any attached analysers. 
+  def run(stage, state)
+    input_data = @inputs.map { |i| i.run(stage, state) }
+    self.method(stage).invoke(state, input_data)
+  end
+
+  # All stage handlers are protected and should not be called directly!
+  # Instead the 'run' method must be used so that input data is gathered
+  # for the analyser.
+  protected
+
+  # This analysis hook is called prior to the start of each generation.
+  #
+  # *Parameters:*
+  # * state, the current state of the evolution.
+  # * input_data, the data provided by the attached input analysers.
+  def before_generation(state, input_data = nil); end
+
+  # This analysis hook is called after the end of a generation.
+  #
+  # *Parameters:*
+  # * state, the current state of the evolution.
+  # * input_data, the data provided by the attached input analysers.
+  def after_generation(state, input_data = nil); end
+
+  # This analysis hook is called upon termination of the evolution.
+  #
+  # *Parameters:*
+  # * state, the current state of the evolution.
+  # * input_data, the data provided by the attached input analysers.
+  def on_termination(state, input_data = nil); end
+  alias_method :after_run, :on_termination
+
+end

data/lib/core/breeder.rb

@@ -0,0 +1,68 @@
+#
+#
+# The breeder is decoupled from the evolver, subpopulation and population models.
+# This allows the breeder to be used in a number of different configurations, where
+# one breeder is used per evolver, population or sub-population.
+class Wallace::Breeder
+
+  attr_reader :elitism,
+              :graph,
+              :threads
+
+  # Constructs a new breeder.
+  #
+  # *Arguments*
+  # * opts, a hash of keyword options for this method.
+  #   -> graph, the breeding graph for this breeder.
+  #   -> elitism, the number (or fraction) of fittest individuals that should be carried over to the
+  #   next generation. (default = 0).
+  #   -> threads, the number of threads the breeding process is split across. (default = 1).
+  def initialize(opts = {})
+    @elitism = opts[:elitism]
+    @threads = opts[:threads] || 1
+    @graphs = Array.new(@threads) { opts[:graph].clone }
+  end
+
+  # Breeds the next generation of individuals for the given subpopulation.
+  #
+  # *Parameters:*
+  # * rng, random number generation to use during breeding.
+  # * subpopulation, the target subpopulation.
+  def breed!(rng, subpopulation)
+
+    # Prepare the candidate list for each input for all graphs.
+    @graphs[0].inputs.each_index do |i|
+      candidates = subpopulation.contents
+      @graphs.each_index do |g|
+        candidates = @graphs[g].inputs[i].prepare!(candidates, random: rng, processed: g > 0)
+      end
+    end
+
+    # Create a temporary array for the new sub-population.
+    size = subpopulation.contents.size
+    buffer = Array.new(size)
+
+    # Add the elite individuals to the end of the sub-population if elitism is enabled.
+    elites = @elitism.nil? ? 0 : @elitism
+    elites = elites.value * size if elites.is_a? Wallace::Fraction
+    buffer[(size - elites)...size] = subpopulation.contents.nmin(elites)
+
+    # Spread the breeding process across multiple threads.
+    # using a separate breeding graph for each thread to ensure thread-safety.
+    thread_size = (size/@threads.to_f).ceil
+    (0...@threads).peach(@threads) do |t|
+      range = t * thread_size
+      range = range...([size, range + thread_size].min)
+
+      @graphs[t].breed!(rng, buffer, range)
+    end
+
+    # Clean each breeding graph.
+    @graphs.each { |g| g.clean! }
+
+    # Swap the contents of the sub-population with the buffer.
+    subpopulation.contents = buffer
+
+  end
+
+end

data/lib/core/breeding_graph.rb

@@ -0,0 +1,59 @@
+class Wallace::BreedingGraph
+
+  attr_reader :outputs,
+              :inputs,
+              :nodes
+
+  # Constructs a new BreedingGraph.
+  #
+  # *Parameters:*
+  # * opts, a hash of keyword options.
+  #   -> outputs, an array of terminal nodes in this breeding graph (can be weighted).
+  #   -> buffered, flag indicating whether the process should be buffered.
+  def initialize(opts = {})
+
+    @outputs = opts[:outputs]
+    @buffered = opts[:buffered] || true
+
+    # Produce a list of nodes in the graph and find all inputs to the graph.
+    @nodes = []
+    @inputs = []
+    queue = @outputs.clone
+
+    until queue.empty?
+      node = queue.shift
+      @nodes << node
+      if node.is_a? Wallace::BreedingGraph::InputNode
+        @inputs << node
+      else
+        queue += node.inputs.map{ |i| i.source }
+      end
+    end
+
+  end
+
+  # Discards all temporary information regarding the last breeding
+  # cycle and clears all the buffers.
+  def clean!
+    @nodes.each { |n| n.clean! }
+  end
+
+  # Breeds a portion of the associated given sub-population for the next generation.
+  #
+  # *Parameters:*
+  # * rng, the RNG to use when breeding individuals.
+  # * buffer, the buffer for the contents of the sub-population of the next generation.
+  # * range, the range of indices to be populated in the buffer by newly bred individuals.
+  def breed!(rng, buffer, range)
+    range.each { |i| buffer[i] = @outputs.sample(random: rng).take!(rng) }
+  end
+
+  # Creates a clone of this breeding graph.
+  def clone
+    Wallace::BreedingGraph.new(
+      outputs: @outputs.map { |n| n.clone },
+      buffered: @buffered
+    )
+  end
+
+end

data/lib/core/breeding_graph/init.rb

@@ -0,0 +1,3 @@
+require_relative 'node.rb'
+require_relative 'input_node.rb'
+require_relative 'node_input.rb'

data/lib/core/breeding_graph/input_node.rb

@@ -0,0 +1,55 @@
+# Used to represent input nodes (i.e. sub-population selection nodes) in the
+# breeding graph.
+class Wallace::BreedingGraph::InputNode < Wallace::BreedingGraph::Node
+
+  # Constructs a new input node.
+  #
+  # *Parameters:*
+  # * selector, the selection method used by this input node.
+  def initialize(selector)
+    super(selector, [])
+    @candidates = []
+  end
+
+  alias :selector :function
+
+  # Selects a single individual from the list of candidates using the selection method
+  # associated with this node.
+  #
+  # *Parameters:*
+  # * rng, the RNG to use when selecting an individual from the list of candidates.
+  def take!(rng)
+    @function.produce(rng, @candidates).clone
+  end
+
+  # Prepares this input node for the next breeding cycle by supplying the contents
+  # of the sub-population and performing any necessary post-processing.
+  #
+  # To prevent redundant post-processing when using multiple threads, we can supply
+  # a prepared candidate list from the same input node from an other breeding graph.
+  #
+  # *Parameters:*
+  # * candidates, a list of (possibly post-processed) candidates for selection.
+  # * opts, a hash of keyword options for this method.
+  #   -> random, the RNG to use when preparing the candidate list.
+  #   -> processed, a flag indicating if this candidate list has already been post-processed.
+  #
+  # *Returns:*
+  # The prepared candidate list (so that it can be exploited by identical nodes in other graphs).
+  def prepare!(candidates, opts = {})
+    @candidates = opts[:processed] ? candidates.clone : @function.prepare(candidates, opts)
+    return @candidates
+  end
+
+  # Creates a clone of this node and its inputs.
+  def clone
+    Wallace::BreedingGraph::InputNode.new(@function)
+  end
+
+  # Clears the contents of the buffer and candidates list for this input node.
+  def clean!
+    super
+    @candidates.clear
+  end
+
+end

data/lib/core/breeding_graph/node.rb

@@ -0,0 +1,68 @@
+# Represents a node within the breeding graph.
+#
+# Each node corresponds to a stage within the breeding process and is associated with
+# a given operator or selection method which is used on the inputs to that node to produce
+# some individuals for the next generation or for further processing by successive nodes in
+# the graph.
+class Wallace::BreedingGraph::Node
+
+  attr_reader :function,
+              :inputs
+
+  # Constructs a node for the breeding graph.
+  #
+  # *Parameters:*
+  # * function, the operator or selection method associated to this node.
+  # * inputs, an array of inputs to this node.
+  def initialize(function, inputs)
+    @inputs = inputs
+    @function = function
+    @buffer = []
+  end
+
+  # Takes and returns a single individual produced (or selected) by this node.
+  #
+  # If there are no individuals held in the buffer then a number are produced
+  # (or selected) using the operator (or selection method) attached to this node.
+  #
+  # *Parameters:*
+  # * rng, the RNG to use if new individuals are bred.
+  #
+  # *Returns:*
+  #  An array of individuals produced at this node.
+  def take!(rng)
+    @buffer += @function.produce(rng, generate_inputs!(rng)) if @buffer.empty?
+    return @buffer.pop
+  end
+
+  # Clears the buffer of this node and discards any temporary
+  # information relating to the breeding processs.
+  def clean!
+    @buffer.clear
+  end
+
+  # Creates a clone of this node and its inputs.
+  def clone
+    Wallace::BreedingGraph::Node.new(
+      @function,
+      @inputs.map { |i| Wallace::BreedingGraph::NodeInput.new(i.source.clone, i.size) }
+    )
+  end
+
+  protected
+
+  # Generates a set of individuals to use as input to this node using the information
+  # in the list of associated node inputs.
+  #
+  # *Parameters:*
+  # * rng, the RNG to use when producing individuals up the breeding chain.
+  #
+  # *Returns:*
+  # An array of individuals to use as input for this node.
+  def generate_inputs!(rng)
+    return @inputs.reduce([]) do |inds, input|
+      inds += Array.new(input.size) { input.source.take!(rng) }
+    end
+  end
+
+end

data/lib/core/breeding_graph/node_input.rb

@@ -0,0 +1,6 @@
+# Used to represent inputs to a given node in the breeding graph.
+#
+# *Attributes:*
+# * source, the source node to retrieve individuals from.
+# * size, the number of individuals to retrieve from the source.
+Wallace::BreedingGraph::NodeInput = Struct.new(:source, :size)