wallace 0.0.0

data/lib/modules/koza/builder/full_builder.rb

@@ -0,0 +1,92 @@
+# The Full builder constructs Koza trees according to a slight variant of Koza's
+# FULL method. Unlike Koza's original FULL method, this FULL method allows single
+# node trees to be constructed.
+#
+# A random integer d is selected as the depth of the tree, between the minimum
+# and maximum depth limits inclusively. A  full tree of exactly depth d is
+# then generated.
+class Wallace::Koza::Builder::FullBuilder < Wallace::Koza::Builder
+
+  # Builds a full subtree of a given depth using a variant
+  # of Koza's FULL method (where single element sub-trees are acceptable).
+  #
+  # *Parameters:*
+  # * terminals, the list of terminals.
+  # * non_terminals, the list of non-terminals.
+  # * depth, the depth of the sub-tree.
+  # * opts, a hash of keyword options for this method.
+  #   -> random, the RNG to use for building the subtree.
+  #
+  # *Returns:*
+  # The root node of the built sub-tree.
+  def self.full_subtree(terminals, non_terminals, depth, opts = {})
+
+    opts[:random] ||= Random.new
+
+    # If we require a sub-tree of depth one then we simply return a node with a value
+    # sampled from the set of terminals.
+    return Wallace::Koza::KozaNode.new(terminals.sample(random: opts[:random])) if depth == 0
+
+    # Construct the children of each node in the queue until there are no nodes
+    # left to process. We assume that the node to be processed has children. This
+    # is fine to assume since sub-trees of length one are created and returned above, and
+    # terminal nodes aren't added to the queue for processing.
+    root = Wallace::Koza::KozaNode.new(non_terminals.sample(random: opts[:random]), depth: 0)
+    queue = [root]
+    until queue.empty?
+
+      parent = queue.shift
+      parent.children = Array.new(parent.arity) do
+
+        # To achieve a full tree we simply sample from the non-terminal set until the child
+        # is at the maximum depth.
+        if (parent.depth + 1) == depth
+          value = terminals.sample(random: opts[:random])
+        else
+          value = non_terminals.sample(random: opts[:random])
+        end
+
+        # Build the node and add it to the queue (provided it isn't terminal).
+        node = Wallace::Koza::KozaNode.new(value, parent: parent, depth: parent.depth + 1)
+        queue << node unless node.terminal?
+        node
+
+      end unless parent.terminal?
+
+    end
+    return root
+
+  end
+
+  # Builds a full tree whose depth is between the minimum and maximum depths
+  # inclusively and every sub-tree is full.
+  #
+  # *Parameters:*
+  # * opts, a hash of keyword options for this method.
+  #   -> random, the RNG to use for building the tree.
+  #
+  # *Returns:*
+  # The built tree.
+  def build_tree(opts = {})
+    opts[:random] ||= Random.new
+    depth = opts[:random].rand(@depth_limits)
+    Wallace::Koza::KozaTree.new(build_subtree(depth, random: opts[:random]))
+  end
+
+  # Builds a full subtree of a given maximum depth.
+  #
+  # *Parameters:*
+  # * depth, the maximum depth of the sub-tree.
+  # * opts, a hash of keyword options for this method.
+  #   -> random, the RNG to use for building the subtree.
+  #
+  # *Returns:*
+  # The root node of the built sub-tree.
+  #
+  # *See*
+  # FullBuilder.full_subtree
+	def build_subtree(depth, opts = {})
+    self.class.full_subtree(@terminals, @non_terminals, depth, opts)
+  end
+
+end

data/lib/modules/koza/builder/grow_builder.rb

@@ -0,0 +1,103 @@
+# The Grow builder constructs Koza trees according to a slight variant of Koza's
+# GROW method. Unlike Koza's original GROW method, this GROW method allows single
+# node trees to be constructed.
+#
+# A random integer d is selected as the depth of the tree, between the minimum
+# and maximum depth limits inclusively. A tree of up to depth d is then generated.
+# At each stage we determine whether a node should be terminal or not by checking if
+# the maximum depth has been reached, or some random number falls within the bounds of
+# probability that a terminal should be selected. 
+class Wallace::Koza::Builder::GrowBuilder < Wallace::Koza::Builder
+
+  # The probability that a terminal will be selected when constructing a node using the GROW method.
+  attr_accessor :probability_terminal
+
+  # Builds a full subtree of a given maximum depth using a variant
+  # of Koza's GROW method (where single element sub-trees are acceptable).
+  #
+  # *Parameters:*
+  # * probability_terminal, the probability that a terminal node will be created at each stage.
+  # * opts, a hash of keyword options for this method.
+  #   -> random, the RNG to use for building the subtree.
+  #
+  # *Returns:*
+  # The root node of the built sub-tree.
+  def self.grow_subtree(terminals, non_terminals, max_depth, probability_terminal, opts = {})
+
+    opts[:random] ||= Random.new
+
+    # If the maximum depth of the sub-tree is zero then we simply return a node with a value
+    # sampled from the set of terminals. If the maximum depth of the sub-tree is greater than one
+    # then we check if the first node is a terminal and if so, we also return a single terminal
+    # node.
+    if max_depth == 0 or opts[:random].rand <= probability_terminal
+      return Wallace::Koza::KozaNode.new(terminals.sample(random: opts[:random]))
+    end
+
+    # Construct the children of each node in the queue until there are no nodes
+    # left to process. We decide whether each child is terminal or non-terminal according to the
+    # associated probability of a terminal being selected. If the maximum depth has been reached then
+    # we force the child to be a terminal.
+    root = Wallace::Koza::KozaNode.new(non_terminals.sample(random: opts[:random]), depth: 0)
+    queue = [root]
+    until queue.empty?
+
+      parent = queue.shift
+      parent.children = Array.new(parent.arity) do
+
+        if opts[:random].rand <= probability_terminal or (parent.depth + 1) == max_depth
+          value = terminals.sample(random: opts[:random])
+        else
+          value = non_terminals.sample(random: opts[:random])
+        end
+
+        node = Wallace::Koza::KozaNode.new(value, parent: parent, depth: parent.depth + 1)
+        queue << node unless node.terminal?
+        node
+
+      end unless parent.terminal?
+
+    end
+    return root
+
+  end
+
+  # Constructs a new GrowBuilder.
+  #
+  # *Parameters:*
+  # * probability_terminal, the probability that a terminal node will be built when using the GROW method.
+  def initialize(probability_terminal)
+    @probability_terminal = probability_terminal
+  end
+
+  # Selects a random integer d, where d is between the minimum and maximum tree depth inclusively, and creates
+  # a tree of up to depth d.
+  #
+  # *Parameters:*
+  # * opts, a hash of keyword options for this method.
+  #   -> random, the RNG to use for building the tree.
+  #
+  # *Returns:*
+  # The built tree.
+  def build_tree(opts = {})
+    opts[:random] ||= Random.new
+    Wallace::Koza::KozaTree.new(build_subtree(opts[:random].rand(@depth_limits), random: opts[:random]))
+  end
+
+  # Builds a full subtree of a given maximum depth.
+  #
+  # *Parameters:*
+  # * max_depth, the maximum depth of the sub-tree.
+  # * opts, a hash of keyword options for this method.
+  #   -> random, the RNG to use for building the subtree.
+  #
+  # *Returns:*
+  # The root node of the built sub-tree.
+  #
+  # *See*
+  # FullBuilder.full_subtree
+  def build_subtree(max_depth, opts = {})
+    self.class.grow_subtree(@terminals, @non_terminals, max_depth, @probability_terminal, opts)
+  end
+
+end

data/lib/modules/koza/builder/half_builder.rb

@@ -0,0 +1,70 @@
+# The Half Builder is a (slightly modified) implementation of Koza's Ramped Half-and-Half builder.
+#
+# It works by selecting a random integer d, between the minimum and maximum depth inclusively.
+# probability_grow of the time the grow method is used to generate a tree of up to depth d using the
+# GROW builder. (1-probability_grow) of the time the FULL method is used to generate trees of exactly
+# depth d.
+class Wallace::Koza::Builder::HalfBuilder < Wallace::Koza::Builder
+
+  # The probability that the GROW method will be used to generate a tree.
+  attr_reader :probability_grow
+
+  # The probability that a terminal will be selected when constructing a node using the GROW method.
+  attr_accessor :probability_terminal
+
+  # Constructs a new HalfBuilder.
+  #
+  # *Parameters:*
+  # * probability_grow, the probability that the GROW method will be used when generating a tree.
+  # * probability_terminal, the probability that a terminal node will be built when using the GROW method.
+  def initialize(probability_grow, probability_terminal)
+    @probability_grow = probability_grow
+    @probability_terminal = probability_terminal
+  end
+
+  # Returns the probability that the FULL method will be used to generate a tree.
+  def probability_full
+    1.0 - @probability_grow
+  end
+
+  # Builds a new Koza Tree of depth d, where d is within the allowed minimum and maximum
+  # tree depths, using either the GROW or FULL method.
+  #
+  # *Parameters:*
+  # * opts, a hash of keyword options for this method.
+  #   -> random, the RNG to use for the process.
+  #
+  # *Returns:*
+  # A new Koza tree.
+  def build_tree(opts = {})
+    Wallace::Koza::KozaTree.new(build_subtree(@depth_limits.sample, random: opts[:random]))
+  end
+
+  # Builds a new subtree of a maximum given depth using either the GROW or FULL method.
+  #
+  # *Parameters:*
+  # * depth, the (maximum) depth of the subtree.
+  # * opts, a hash of keyword options for this method.
+  #   -> random, the RNG to use for the process.
+  def build_subtree(depth, opts = {})
+
+    opts[:random] ||= Random.new
+
+    return Wallace::Koza::Builder::GrowBuilder.grow_subtree(
+      @terminals,
+      @non_terminals,
+      depth,
+      @probability_terminal,
+      random: opts[:random]
+    ) if @probability_grow <= opts[:random].rand
+
+    return Wallace::Koza::Builder::FullBuilder.full_subtree(
+      @terminals,
+      @non_terminals,
+      depth,
+      random: opts[:random]
+    )
+
+  end
+
+end

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

@@ -0,0 +1,3 @@
+require_relative 'full_builder.rb'
+require_relative 'grow_builder.rb'
+require_relative 'half_builder.rb'

data/lib/modules/koza/ephemeral.rb

@@ -0,0 +1,33 @@
+# An ephemeral instance is a special type of terminal symbol which only assumes its value (from a set
+# of possible values) once it is selected. The Ephemeral class is used to store the set of possible values
+# that a given ephemeral instance can take.
+#
+# It is possible to bias the selection of values by the Ephemeral by using a weighted collection or a distribution.
+#
+# *Parameters:*
+# * values, the range, set or collection of values instances of the ephemeral can assume.
+class Wallace::Koza::Ephemeral
+
+  # Constructs a new Ephemeral.
+  #
+  # *Parameters:*
+  # * values, the collection of values that instances of this ephemeral can take.
+  def initialize(values)
+    @values = values
+  end
+
+  # Samples a possible value for this ephemeral.
+  #
+  # *Parameters:*
+  # * opts, a hash of keyword parameters to this method.
+  #   -> random, the RNG to use when sampling a value.
+  def sample(opts = {})
+    Wallace::Koza::EphemeralInstance.new(@values.sample)
+  end
+
+end
+
+# Holds the value of an ephemeral.
+#
+# Unlike standard terminal and non-terminal node values, ephemeral values can be manipulated during breeding.
+class Wallace::Koza::EphemeralInstance < Wallace::Koza::Literal; end

data/lib/modules/koza/init.rb

@@ -0,0 +1,12 @@
+module Wallace::Koza; end
+
+require_relative 'koza_node.rb'
+require_relative 'koza_node_value.rb'
+require_relative 'koza_node_value_set.rb'
+require_relative 'ephemeral.rb'
+require_relative 'builder.rb'
+require_relative 'koza_tree.rb'
+require_relative 'koza_species.rb'
+
+require_relative 'builder/init.rb'
+require_relative 'operators/init.rb'

data/lib/modules/koza/koza_node.rb

@@ -0,0 +1,108 @@
+# This class is used to represent nodes within a Koza tree.
+class Wallace::Koza::KozaNode
+
+  # We allow all attributes to be manipulated from outside but
+  # trust that all modification to trees is performed through the
+  # KozaTree interfaces (which fix depths and calculate the list
+  # of nodes in the tree).
+  attr_accessor :contents,
+                :depth,
+                :parent,
+                :children
+
+	# Constructs a new node for a Koza tree.
+  #
+  # *Parameters:*
+  # * contents, the contents of this node.
+  # * opts, a hash of keyword options for this tree node.
+  #   -> parent, the parent of this node.
+  #   -> children, an array of the children of this node.
+	def initialize(contents, opts = {})
+    @contents = contents
+    @parent = opts[:parent]
+    @children = opts[:children] || []
+    @depth = opts[:depth]
+	end
+
+  # Sets the parent node of this node.
+  #
+  # *Parameters:*
+  # * node, the node to set as the parent of this node.
+  def parent=(node)
+    @parent = node
+  end
+
+  # Checks to see if this node is a root node (i.e. it has no parent).
+  def root?
+    @parent.nil?
+  end
+
+	# Checks to see if this node is a leaf (i.e. it has no children).
+	#
+	# *Returns*
+	# true if leaf, false if not.
+	def leaf?
+		@children.empty?
+	end
+
+  # Checks whether this node contains a terminal value.
+  def terminal?
+    @contents.is_a? Wallace::Koza::Terminal
+  end
+
+  # Checks whether the contents of this node are an ephemeral instance.
+  #
+  # *Returns:*
+  # True if the contents are an ephemeral instance, false if otherwise.
+  def ephemeral?
+    @contents.is_a? Wallace::Koza::EphemeralInstance
+  end
+
+  # Returns the label at this node.
+  def label
+    @contents.label
+  end
+
+  # Returns the value of this node (or the label in the case of non-terminals).
+  def value
+    terminal? ? @contents.value : @contents.label
+  end
+
+  # Returns the arity (number of inputs) to this node.
+  def arity
+    terminal? ? 0 : @contents.arity
+  end
+
+  # Creates a clone of this node (and its children).
+  # Parent node is discarded in the clone (unless specified not to do so).
+  #
+  # *Parameters:*
+  # * opts, a hash of keyword options for this method.
+  #   -> keep_parent, if true maintains depth and parent information.
+  #                   otherwise this information is lost.
+  #
+  # *Returns:*
+  # A clone of this node (and its children).
+  def clone(opts = {})
+    cloned = Wallace::Koza::KozaNode.new(
+      @contents,
+      parent: opts[:keep_parent] ? @parent : nil ,
+      children: @children.map { |c| c.clone })
+    cloned.children.each { |c| c.parent = cloned }
+    return cloned
+  end
+
+  # Evaluates the S-expression given by the sub-tree at this node.
+  #
+  # *Parameters:*
+  # * args, the arguments to the function / program (as a hash).
+  def eval(args)
+    terminal? ? @contents.eval(args) : @contents.eval(@children.map { |c| c.eval(args) })
+  end
+
+  # Converts the sub-tree at this node into a Ruby program string.
+  def to_ruby
+    terminal? ? @contents.value.to_s : "#{@contents.label}(#{@children.map{ |c| c.to_ruby }.join(',')})"
+  end
+
+end

data/lib/modules/koza/koza_node_value.rb

@@ -0,0 +1,72 @@
+# Used to represent an option from either the terminal or non-terminal set.
+class Wallace::Koza::KozaNodeValue; end
+
+# Holds an option from the terminal set.
+class Wallace::Koza::Terminal < Wallace::Koza::KozaNodeValue
+
+  attr_reader :value
+
+  # Constructs a terminal.
+  #
+  # *Parameters:*
+  # * value, the value of the node.
+  def initialize(value)
+    @value = value
+  end
+
+end
+
+# Holds a variable option from the terminal set.
+class Wallace::Koza::Variable < Wallace::Koza::Terminal
+
+  # Evaluates this terminal.
+  #
+  # *Parameters:*
+  # * args, the arguments to the program.
+  def eval(args)
+    args[@value.to_sym]
+  end
+
+end
+
+# Holds a literal option from the terminal set.
+class Wallace::Koza::Literal < Wallace::Koza::Terminal
+
+  # Evaluates this terminal.
+  #
+  # *Parameters:*
+  # * args, the arguments to the program.
+  def eval(args)
+    @value
+  end
+
+end
+
+# Holds an option from the non-terminal set.
+class Wallace::Koza::NonTerminal < Wallace::Koza::KozaNodeValue
+
+  attr_reader :arity,
+              :label,
+              :function
+
+  # Constructs a non-terminal.
+  #
+  # *Parameters:*
+  # * label, the label of the non-terminal.
+  # * arity, the number of inputs to the non-terminal.
+  # * function, the function object for this non-terminal.
+  def initialize(label, arity, function)
+    @label = label
+    @arity = arity
+    @function = function
+  end
+
+  # Evaluates this non-terminal.
+  #
+  # *Parameters:*
+  # * inputs, the input values to this non-terminal function.
+  def eval(inputs)
+    @function.call(*inputs)
+  end
+
+end