wallace 0.0.0

data/lib/modules/koza/koza_node_value_set.rb

@@ -0,0 +1,51 @@
+# Used to hold terminal or non-terminal values.
+class Wallace::Koza::NodeValueSet
+
+  # Constructs a new node value set.
+  #
+  # *Parameters:*
+  # * contents, the contents of the set.
+  def initialize(contents)
+    @contents = contents
+  end
+
+  # Returns an option at a given index from the set.
+  #
+  # *Parameters:*
+  # * index, the index of the option in the set.
+  def [](index)
+    @contents[index]
+  end
+
+end
+
+# Holds the set of terminal values.
+class Wallace::Koza::TerminalSet < Wallace::Koza::NodeValueSet
+
+  # Samples an option from this set.
+  #
+  # *Parameters:*
+  # * opt, a hash of keyword options for this method.
+  #   -> random, the RNG to use to sample an option.
+  def sample(opts = {})
+    opts[:random] ||= Random.new
+    value = @contents.sample(random: opts[:random])
+    value = value.sample(random: opts[:random]) if value.is_a? Wallace::Koza::Ephemeral
+    return value
+  end
+
+end
+
+# Holds the set of non-terminal values.
+class Wallace::Koza::NonTerminalSet < Wallace::Koza::NodeValueSet
+
+  # Samples an option from this set.
+  #
+  # *Parameters:*
+  # * opt, a hash of keyword options for this method.
+  #   -> random, the RNG to use to sample an option.
+  def sample(opts = {})
+    @contents.sample(random: opts[:random] || Random.new)
+  end
+
+end

data/lib/modules/koza/koza_species.rb

@@ -0,0 +1,48 @@
+class Wallace::Koza::KozaSpecies < Wallace::Species
+
+  name = :koza_tree
+
+  attr_reader :terminals,
+              :non_terminals,
+              :builder,
+              :depth_limits
+
+  # Constructs a new koza tree-based species.
+  #
+  # *Parameters:*
+  # * opts, hash of keyword options used by this method.
+  #   -> id, the unique identifier for this species.
+  #   -> terminals, the set of terminal nodes.
+  #   -> non_terminals, the set of non-terminal nodes.
+  #   -> builder, the build method used to generate new trees and sub-trees.
+  #   -> depth_limits, the range of depths trees in this species may have.
+  def initialize(opts = {})
+    super(opts)
+    @terminals = Wallace::Koza::TerminalSet.new(opts[:terminals])
+    @non_terminals = Wallace::Koza::NonTerminalSet.new(opts[:non_terminals])
+    @builder = opts[:builder] || Wallace::Koza::Builder::HalfBuilder.new
+    @depth_limits = opts[:depth_limits] || (0..6)
+    @builder.prepare(@terminals, @non_terminals, @depth_limits)
+  end
+
+  # Checks whether a given tree meets the depth constraints of the species.
+  def valid_tree?(tree)
+    @depth_limits.cover?(tree.length)
+  end
+
+  # Check that a given individual meets the depth constraints of the species.
+  def valid?(individual)
+    return false unless super(individual)
+    return false unless valid_tree?(individual.data)
+  end
+
+  # Creates a new koza tree based individual using the constraints of the species.
+  #
+  # *Parameters:*
+  # * opts, hash of keyword options used by this method.
+  #   -> random, the RNG to use when spawning a new individual.
+  def spawn(opts = {})
+    Wallace::Individual.new(self, @builder.build_tree(random: opts[:random] || Random.new))
+  end
+
+end

data/lib/modules/koza/koza_tree.rb

@@ -0,0 +1,159 @@
+# This class is used to represent Koza Trees, which in turn represent computer programs using
+# Lisp-style S-expressions (program trees).
+#
+# * remove(n)
+class Wallace::Koza::KozaTree
+
+  attr_reader :root,
+              :depth,
+              :nodes
+
+	# Constructs a new Koza Tree.
+  #
+  # *Parameters:*
+  # * root, the root node of this tree.
+	def initialize(root)
+    @root = root
+    calculate!
+	end
+
+  # Samples a node (or number of nodes) from the tree at random.
+  #
+  # *Parameters:*
+  # * n, the number of nodes to sample from the tree.
+  # * opts, a hash of keyword options for this method.
+  #   -> size, the number of nodes to sample.
+  #   -> random, the RNG to use for sampling.
+  def sample(opts = {})
+    @nodes.sample(opts[:size], random: opts[:random] || Random.new) unless opts[:size].nil?
+    @nodes.sample(random: opts[:random] || Random.new) 
+  end
+
+  # Returns a node at a given index in the tree.
+  def [](index)
+    @nodes[index]
+  end
+
+  # Returns the number of nodes in the tree.
+  def size
+    @nodes.length
+  end
+  alias :length :size
+
+  # Changes the root of the tree.
+  #
+  # *Parameters:*
+  # * node, the new root node for the tree.
+  def root=(node)
+    @root = node
+    calculate!
+  end
+
+  # (Re)calculates the list of nodes in the tree
+  # and their respective depths.
+  def calculate!
+    queue = [@root]
+    @nodes = [@root]
+    @root.depth = @depth = 0
+
+    until queue.empty?
+      n = queue.shift
+      @depth = [@depth, n.depth].max
+      n.children.each { |c| c.depth = n.depth + 1 }
+      queue += n.children
+      @nodes << n
+    end
+  end
+
+  # Creates a clone of this tree (along with its nodes).
+  def clone
+    Wallace::Koza::KozaTree.new(@root.clone)
+  end
+
+  # Adds a node to the tree as the child of another node.
+  #
+  # *Parameters:*
+  # * parent, The node to use as the parent of the new node.
+  # * child, The node to add to the tree.
+  def add(parent, child)
+  
+    # Could throw an exception if there is no room for the child.
+    parent.children << child
+    child.parent = parent
+    child.depth = parent.depth + 1
+
+    @nodes << child
+    @depth = child.depth if child.depth > @depth
+
+  end
+
+  # Replaces a subtree in the tree with another subtree.
+  #
+  # *Parameters:*
+  # * n1, the root node of the sub-tree being replaced.
+  # * n2, the root node of the replacement sub-tree.
+  def replace(n1, n2)
+
+    # Create a clone of n2 (to avoid affecting another tree).
+    n2 = n2.clone
+    
+    # If n1 is the root of the tree then change the root to n2.
+    if @root == n1
+      @root = n2
+      n2.parent = nil
+      
+    # Otherwise replace n1 with n2 in n1's parents list of children.
+    else
+      i = n1.parent.children.index(n1)
+      n1.parent.children[i] = n2
+      n2.parent = n1.parent
+      n1.parent = nil
+    end
+  
+    # Recalculate the node list and tree depth.
+    calculate!
+  
+  end
+
+  # Evaluates the S-expression given by this tree.
+  #
+  # *Parameters:*
+  # * args, the arguments to the function / program (as a hash).
+  def eval(args)
+    @root.eval(args)
+  end
+
+  # Converts this tree into a Ruby program string.
+  def to_ruby
+    @root.to_ruby
+  end
+  alias :to_s :to_ruby
+
+  # Compiles a given Koza Tree into a Ruby lambda function.
+  #
+  # *Parameters:*
+  # * args, an array of the arguments to the function.
+  # * tree, the tree to compile to a lambda function.
+  #
+  # *Returns:*
+  # the compiled lambda function.
+  #
+  # *NOTE:*
+  # Trying to call 'eval' in an object method causes huge problems!
+  # Totally different semantics.
+  def self.to_lambda(args, tree)
+    eval("lambda { |#{args.join(',')}| #{tree.to_ruby} }")
+  end
+
+  # Compiles this Koza Tree into a Ruby lambda function.
+  #
+  # *Parameters:*
+  # * args, an array of the arguments to the function.
+  #
+  # *Returns:*
+  # the compiled lambda function.
+  def to_lambda(args)
+    self.class.to_lambda(args, self)
+  end
+
+end

data/lib/modules/koza/operators/init.rb

@@ -0,0 +1,4 @@
+module Wallace::Koza::Operators; end
+
+require_relative 'subtree_crossover_operation.rb'
+require_relative 'subtree_mutation_operation.rb'

data/lib/modules/koza/operators/subtree_crossover_operation.rb

@@ -0,0 +1,43 @@
+# The subtree crossover operator takes two parent koza trees, selects a sub-tree from each
+# of them at random and swaps them to give two offspring.
+class Wallace::Koza::Operators::SubtreeCrossoverOperator < Wallace::Operator
+
+  name = :subtree_crossover
+
+  # Constructs a new subtree crossover operator.
+  #
+  # *Parameters:*
+  # * id, the unique identifier for this operator.
+  # * inputs, an array of inputs (OperatorInput) to this operator.
+  # * max_tries, the maximum number of tries at recombining individuals before the inputs are returned.
+  def initialize(id, inputs, max_tries)
+    super(id, inputs)
+    @max_tries = max_tries
+  end
+
+  protected
+  def produce(rng, individuals)
+
+    species = individuals[0].species
+    tries = 0
+    tx, ty = nil
+    loop do
+      tx = individuals[0].data.clone
+      ty = individuals[1].data.clone
+      nx = tx.sample(random: rng)
+      ny = ty.sample(random: rng)
+      tx.replace(nx, ny)
+      ty.replace(ny, nx)
+      tries += 1
+      break if (species.valid_tree?(tx) and species.valid_tree?(ty)) or tries == @max_tries
+    end
+
+    # Return the recombined individuals so long as they are legal.
+    # If they are not legal then return the input individuals.
+    individuals[0].data = tx if species.valid_tree?(tx)
+    individuals[1].data = ty if species.valid_tree?(ty)
+    return individuals
+  
+  end
+
+end

data/lib/modules/koza/operators/subtree_mutation_operation.rb

@@ -0,0 +1,32 @@
+# The subtree mutation operation selects a random sub-tree within a given tree
+# and replaces it with a valid sub-tree constructed using the builder attached to the
+# individual's species.
+class Wallace::Koza::Operators::SubtreeMutationOperator < Wallace::Operator
+
+  name = :subtree_mutation
+
+  # Idea: We could add a 'prepare' method to this operator so that
+  # it can cache the tree builder.
+
+  protected
+  def produce(rng, individuals)
+
+    # Select a random sub-tree from the individual.
+    node = individuals[0].data.sample(random: rng)
+
+    # Determine the depth of the replacement sub-tree.
+    depth = individuals[0].species.depth_limits
+    depth = ([0, depth.min - node.depth].max .. (depth.max - node.depth))
+    depth = depth.sample(random: rng)
+
+    # Generate the replacement and swap it with the original.
+    replacement = individuals[0].species.builder.build_subtree(
+      depth,
+      random: rng
+    )
+    individuals[0].data.replace(node, replacement)
+    return individuals 
+  
+  end
+
+end

data/lib/operators/bit_flip_mutation_operation.rb

@@ -0,0 +1,29 @@
+class Wallace::Operators::BitFlipMutationOperator < Wallace::Operator
+
+  name = :bit_flip_mutation
+
+  # Allow the mutation probability to be dynamically adjusted.
+  attr_accessor :probability
+
+  # Constructs a new bit flip mutation operator.
+  #
+  # *Parameters:*
+  # * opts, a hash of keyword options for this method.
+  #   -> id, the unique identifier for this operator.
+  #   -> inputs, an array of inputs (OperatorInput) to this operator.
+  #   -> probability, the probability that a given bit should be mutated. (default = 0.01).
+  def initialize(opts = {})
+    super(opts)
+    @probability = opts[:probability] || 0.01
+  end
+
+  def operate(rng, inputs)
+    (0...inputs[0].length).each do |i|
+      if rng.rand <= @probability
+        inputs[0][i] = inputs[0][i] == 0 ? 1 : 0
+      end
+    end
+    return inputs
+  end
+
+end

data/lib/operators/boundary_mutation_operation.rb

@@ -0,0 +1,28 @@
+class Wallace::Operators::BoundaryMutationOperator < Wallace::Operator
+
+  name = :boundary_mutation
+
+  # Constructs a new boundary mutation operator.
+  #
+  # *Parameters:*
+  # * opts, a hash of keyword options for this method.
+  #   -> id, the unique identifier for this operator.
+  #   -> inputs, an array of inputs (OperatorInput) to this operator.
+  #   -> values, the collection of values that each gene can take.
+  def initialize(opts = {})
+    super(opts)
+    @values = opts[:values] # Extract this from the species?
+  end
+
+  def operate(rng, inputs)
+   # x = inputs[0]
+
+    # Select a gene to mutate.
+    #index = rng.rand(x.data.length)
+    
+    #x.data[rng.rand(x.data.length)] =
+    
+    return inputs
+  end
+
+end

data/lib/operators/cycle_crossover_operation.rb

@@ -0,0 +1,77 @@
+# *Credit:*
+# Oliver, I. M., Smith, D. J., & Holland, J. R. C. (1987). A 
+# study of permutation crossover operators on the traveling 
+# salesman problem. In Proceedings of the second 
+# international conference. on genetic algorithms (ICGA’87) 
+# (pp. 224–230). Cambridge, MA:Massachusetts Institute of 
+# Technology
+class Wallace::Operators::CycleCrossoverOperator < Wallace::Operator
+
+  name = :cycle_crossover
+
+  HashPair = Struct.new(:v1, :v2, :i2)
+
+  def operate(rng, parents)
+
+    # http://www.rubicite.com/Tutorials/GeneticAlgorithms/CrossoverOperators/CycleCrossoverOperator.aspx
+    length = parents[0].length
+    children = [
+      Array.new(length) { nil },
+      Array.new(length) { nil }
+    ]
+
+    # Generate a hash to indicate when certain indices have been
+    # used in a cycle.
+    used = Hash[(0...length).map { |v| [v, false] }]
+
+    # REVERSE ENGINEER.
+    helper = Hash[(0...length).map { |v|
+      temp_pair = HashPair.new(
+        parents[0][v],
+        parents[1][v],
+        v
+      )
+      [parents[1][v], temp_pair]
+    }]
+
+    cycles = []
+    (0...length).each do |j|
+      cyc = []
+      unless used[j] then
+        
+        cyc_start = j
+
+        temp_pair = helper[parents[0][cyc_start]]
+        cyc << temp_pair
+        used[temp_pair.i2] = true
+
+        until temp_pair.i2 == cyc_start
+          temp_pair = helper[parents[0][temp_pair.i2]]
+          cyc << temp_pair
+          used[temp_pair.i2] = true
+        end
+
+      end
+      cycles << cyc
+    end
+
+    # Alternating cycles.
+    cycles.each_with_index do |cyc, num|
+      if (num % 2) == 0
+        cyc.each do |temp_pair|
+          children[0][temp_pair.i2] = temp_pair.v1
+          children[1][temp_pair.i2] = temp_pair.v2
+        end
+      else
+        cyc.each do |temp_pair|
+          children[0][temp_pair.i2] = temp_pair.v2
+          children[1][temp_pair.i2] = temp_pair.v1
+        end
+      end
+    end
+
+    return children
+
+  end
+
+end