wallace 0.0.0

data/lib/operators/swap_mutation_operation.rb

@@ -0,0 +1,29 @@
+# The swap mutation operator swaps pairs of consecutive genes according to
+# an associated probability.
+class Wallace::Operators::SwapMutationOperator < Wallace::Operator
+
+  name = :swap_mutation
+
+  # Allow the swap probability to be dynamically adjusted.
+  attr_accessor :probability
+
+  # Constructs a new swap 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 pair (of consecutive genes) should be swapped. (default = 0.05).
+  def initialize(opts = {})
+    super(opts)
+    @probability = opts[:probability] || 0.05
+  end
+
+  def operate(rng, inputs)
+      (0...inputs[0].length).each_cons(2) do |g1, g2|
+        inputs[0][g1], inputs[0][g2] = inputs[0][g2], inputs[0][g1] if rng.rand <= @probability
+      end
+      return inputs
+  end
+
+end

data/lib/operators/three_parent_crossover_operation.rb

@@ -0,0 +1,16 @@
+# Three parent crossover takes three individuals as parents, A, B and C, and
+# combines them to form a single child D. At each point in the chromosome, the
+# values of A and B are compared; if they are the same then that value is used,
+# otherwise the value at C is used.
+class Wallace::Operators::ThreeParentCrossoverOperator < Wallace::Operator
+
+  name = :three_parent_crossover
+
+  def operate(rng, inputs)
+    (0...inputs[0].length).each do |i|
+      inputs[0][i] = inputs[2][i] if inputs[0][i] != inputs[1][i]
+    end
+    return [inputs[0]]
+  end
+
+end

data/lib/operators/two_point_crossover_operation.rb

@@ -0,0 +1,31 @@
+# Two-point crossover takes two individuals, A and B, as parents, and produces two children by
+# swapping the substrings between loci, X and Y.
+#
+# Two crossover points, X and Y, are chosen such that X and Y both lie within the bounds of A and B
+# and that X < Y. The substrings A[X...Y] and B[X...Y] are swapped to produce two (potentially) new
+# children strings.
+class Wallace::Operators::TwoPointCrossoverOperator < Wallace::Operator
+
+  name = :two_point_crossover
+
+  def operate(rng, inputs)
+
+    # Ensure that the individuals are longer than length 2!
+    return inputs if inputs[0].length <= 2 or inputs[1].length <= 2
+
+    # Calculate the crossover points X and Y then swap the substrings
+    # between A and B at those loci.
+    x = rng.rand((1...([inputs[0].length, inputs[1].length].min-1)))
+    y = rng.rand((x...([inputs[0].length, inputs[1].length].min)))
+
+    # Unfortunately []= can not be performed in parallel so we must
+    # find and store a substring before swapping them.
+    t = inputs[0][x...y]
+    inputs[0][x...y] = inputs[1][x...y]
+    inputs[1][x...y] = t
+
+    return inputs
+
+  end
+
+end

data/lib/operators/twors_mutation_operation.rb

@@ -0,0 +1,18 @@
+# The Twors Mutation operator takes an individual and swaps the values
+# of two genes selected at random.
+#
+# Found in:
+# => Analyzing the Performance of Mutation Operators to Solve the Travelling Salesman Problem
+# => Otman ABDOUN, Jaafar ABOUCHABAKA, Chakir TAJANI
+
+class Wallace::Operators::TworsMutationOperator < Wallace::Operator
+
+  name = :twors_mutation
+
+  def operate(rng, inputs)
+    i, j = (0...inputs[0].length).to_a.sample(2)
+    inputs[0][i], inputs[0][j] = inputs[0][j], inputs[0][i]
+    return inputs
+  end
+
+end

data/lib/operators/uniform_crossover_operation.rb

@@ -0,0 +1,30 @@
+# Uniform crossover takes two individuals as parents, A and B, and produces two children, C and D,
+# by swapping genes according to the mixing ratio probability. Using a mixing ratio of 0.5 should
+# result in individuals which share half of their genes with a given parent. 
+class Wallace::Operators::UniformCrossoverOperator < Wallace::Operator
+
+  name = :uniform_crossover
+
+  # Allow the mixing ratio to be dynamically adjusted.
+  attr_accessor :ratio
+
+  # Constructs a new uniform crossover 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.
+  #   -> ratio, the mixing ratio to use during crossover. (default = 0.5).
+  def initialize(opts = {})
+    super(opts)
+    @ratio = opts[:ratio] || 0.5
+  end
+
+  def operate(rng, inputs)
+    (0...inputs[0].length).each do |i|
+      inputs[0][i], inputs[1][i] = inputs[1][i], inputs[0][i] if rng.rand <= @ratio
+    end
+    return inputs
+  end
+
+end

data/lib/operators/uniform_mutation_operation.rb

@@ -0,0 +1,31 @@
+class Wallace::Operators::UniformMutationOperator < Wallace::Operator
+
+  name = :uniform_mutation
+
+  # Allow the mutation probability to be dynamically adjusted.
+  attr_accessor :probability
+
+  # Constructs a new uniform 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 range of values that this mutator should sample from (can be biased by using a weighted array). 
+  #   -> probability, the probability that a given bit should be mutated. (default = 0.01).
+  def initialize(opts = {})
+    super(opts)
+    @values = opts[:values]
+    @probability = opts[:probability] || 0.01
+  end
+
+  def operate(rng, inputs)
+    (0...inputs[0].length).each do |i|
+      if rng.rand <= @probability
+        inputs[0][i] = @values.sample(random: rng)
+      end
+    end
+    return inputs
+  end
+
+end

data/lib/operators/variable_one_point_crossover_operation.rb

@@ -0,0 +1,80 @@
+# The variable one point crossover operator was designed to address the problem of bloat
+# resulting from the crossover on variable length chromosomes using the splice crossover
+# operator.
+#
+# This operator takes two chromosomes as its input, X and Y, and slices each into two
+# subsequences, A and B, and C and D, respectively. The first subsequence of X (A) is
+# combined with the last subsequence of Y (D) to form one of the child chromosomes.
+# The second child is formed by combining the first subsequence of Y (C) with the last
+# subsequence of X (B).
+#
+# The subsequences are chosen at random from the set of legal sub-sequences. More
+# details on the process are given in "operate".
+#
+# The key feature of this operator is that it guarantees that the length of the child
+# chromosomes will fall within some given bounds. This feature helps to control the 
+# problem of bloat in problems using variable length chromosomes and can significantly
+# improve performance in certain cases.
+#
+# *WARNING:* Operates on the assumption that the input individuals obey the length constraints.
+# *WARNING:* The length of each input chromosome must be at least 2, failing this the original
+#            inputs are simply returned.
+#
+# *Author:* Chris Timperley
+class Wallace::Operators::VariableOnePointCrossoverOperator < Wallace::Operator
+
+  attr_accessor :bounds
+
+  # Constructs a new variable one point crossover operator.
+  #
+  # *Parameters:*
+  # * opts, a hash of keyword options for this constructor.
+  #   -> id, the unique identifier for this operator.
+  #   -> bounds, the bounds upon the length of child chromosomes produced by this operator.
+  def initialize(opts = {})
+    super(opts)
+    @bounds = opts[:bounds]
+  end
+
+  # Produces two child chromosomes using two parent chromosomes according to the
+  # rules of this genetic operator.
+  #
+  # *Parameters:*
+  # * rng, the RNG to use to select the crossover point.
+  # * parents, the parent chromosomes used in the operation.
+  #
+  # *Returns:*
+  # An array containing two child chromosomes formed using data from the parent chromosomes.
+  def operate(rng, parents)
+
+    # Calculate the length of each parent.
+    x, y = parents[0].length, parents[1].length
+
+    # If either parent chromosome is shorter than length 2 then return them as the child
+    # chromosomes (else the operation will fail).
+    return parents if x < 2 or y < 2 
+
+    # Pseudo-randomly select the first sub-sequence of X (A) such that
+    # 1 <= |A| < |X|. Let B be the remaining part of X.
+    a = rng.rand(1...x)
+    b = x - a
+
+    # Using the chosen A, find all the possible values of |D| such that
+    # MIN <= |A| + |D| <= MAX. Restrict the set of possible values for |D|
+    # to those which produce a legal |C| (i.e. MIN <= |B| + |C| <= MAX)
+    # before sampling a value uniformly at random.
+    d = ([1, @bounds.min - a].max..[y, @bounds.max - a].min).to_a.select{ |v|
+      @bounds.cover?(b + y - v)
+    }.sample(random: rng)
+    c = y - d
+
+    # Gather and combine the subsequences into the child chromosomes using
+    # their calculated lengths.
+    return [
+      parents[0].first(a) + parents[1].last(d),
+      parents[1].first(c) + parents[0].last(b)
+    ]
+
+  end
+
+end

data/lib/patches/enumerable.rb

@@ -0,0 +1,85 @@
+module Enumerable
+
+  # Returns an array of all consecutive k-tuples in the collection.
+  #
+  # *Parameters:*
+  # * k, the size of the tuples.
+  def cons(k)
+    k_tuples = []
+    each_cons(k) { |tuple| k_tuples << tuple }
+    return k_tuples
+  end
+
+  # Checks whether this collection does not contain a given value V.
+  #
+  # *Parameters:*
+  # * v, the value to check for.
+  #
+  # *Returns:*
+  # true if not contained, false if contained.
+  def exclude?(v)
+    not include?(v)
+  end
+
+  # Calculates and returns the N highest values from this collection.
+  #
+  # *Parameters:*
+  # * n, number of values to return.
+  def nmax(n)
+    result = [] # lowest to highest
+    each do |v|
+      result = result.sorted_insert!(v).last(n) if result.length < n or v > result.first
+    end
+    return result
+  end
+
+  # Calculates and returns the N lowest values from this collection.
+  #
+  # *Parameters:*
+  # * n, number of values to return.
+  def nmin(n)
+    result = [] # lowest to highest
+    each do |v|
+      result = result.sorted_insert!(v).last(n) if result.length < n or v < result.first
+    end
+    return result
+  end
+
+  # Inserts a given value into this collection, assuming that the
+  # collection is sorted.
+  #
+  # *Parameters:*
+  # * value, the value to insert into the collection.
+  #
+  # *Returns:*
+  # The resulting collection.
+  def sorted_insert!(value)
+    index = calculate_sorted_index(value)
+    insert(index, value)
+    return self
+  end
+
+  private
+  
+  # Calculates the index of a given value within this sorted collection.
+  #
+  # *Parameter:*
+  # * value, the value to calculate the index of.
+  #
+  # *Returns:*
+  # * the index of that value within this collection.
+  #
+  # *TODO:*
+  # * This is a rubbish O(n) implementation!
+  # * A RB-binary tree or a better insertion sort method should
+  #   be implemented.
+  def calculate_sorted_index(value)
+    i = 0
+    each do |v|
+      break if v > value
+      i += 1
+    end
+    return i
+  end
+
+end

data/lib/patches/init.rb

@@ -0,0 +1,5 @@
+# This directory contains monkey patches that extend functionality
+# within the built-in Ruby classes and modules.
+
+require_relative 'enumerable.rb'
+require_relative 'range.rb'

data/lib/patches/range.rb

@@ -0,0 +1,13 @@
+class Range
+
+  # Samples a value from within this range.
+  #
+  # *Parameters:*
+  # * opts, keyword options for this method.
+  # *	=> random, the RNG to use to sample from this range.
+  def sample(opts = {})
+  	random = opts[:random] || Random.new
+    random.rand(self)
+  end
+
+end

data/lib/selectors/init.rb

@@ -0,0 +1,5 @@
+module Wallace::Selectors; end
+
+require_relative 'random_selector.rb'
+require_relative 'roulette_selector.rb'
+require_relative 'tournament_selector.rb'

data/lib/selectors/random_selector.rb

@@ -0,0 +1,14 @@
+class Wallace::Selectors::RandomSelector < Wallace::Selector
+
+  name = :random
+
+  # Selects an individual at random from the list of candidates.
+  #
+  # *Arguments*
+  # * rng, random number generator to use to select index of individual.
+  # * candidates, the list of candidates to select from.
+  def produce(rng, candidates)
+    candidates.sample(random: rng)
+  end
+
+end

data/lib/selectors/roulette_selector.rb

@@ -0,0 +1,23 @@
+# NOT READY!
+class Wallace::Selectors::RouletteSelector < Wallace::Selector
+
+  name = :roulette
+
+  # Precomputes the probability distribution prior to selection.
+  def prepare(rng, candidates)
+    sum_fitness = candidates.reduce(0) {|sum, ind| sum += 1.0 / ind.fitness.value.to_f }
+    distribution = Array.new(candidates.length) do |i|
+      (1.0 / candidates[i].fitness.value.to_f) / sum_fitness
+    end
+    @candidates = Wallace::Utility::ScaledArray.new(candidates, distribution)
+  end
+
+  # Selects an individual at random from the list of candidates.
+  #
+  # *Arguments*
+  # * rng, random number generator to use to select index of individual.
+  def select(rng)
+    return @candidates.sample(random: rng)
+  end
+
+end

data/lib/selectors/tournament_selector.rb

@@ -0,0 +1,36 @@
+class Wallace::Selectors::TournamentSelector < Wallace::Selector
+
+  name = :tournament
+
+  # Constructs a new tournament selector.
+  #
+  # *Arguments*
+  # * opts, a hash of keyword options for this method.
+  #   -> size, the size of the tournament. (default = 3).
+  #   -> pick_best, flag indicating if the best individual in the tournament should win.
+  def initialize(opts = {})
+    @size = opts[:size] || 3
+    pick_best = opts[:pick_best] || true
+    @winning_condition = pick_best ? -1 : 1
+    raise ArgumentError, "Tournament size must be greater than 1." if @size < 2
+  end
+
+  # Random samples a number (equal to the tournament size) of individuals
+  # from the list of candidates, and returns the best or worst (depending on
+  # the selector parameters).
+  #
+  # *Arguments*
+  # * rng, random number generator to use to select index of individual.
+  #
+  # *Parameters:*
+  # * rng, random number generator to use to select index of individual.
+  # * candidates, the list of candidates for inclusion within the tournament.
+  #
+  # *Returns:*
+  # The winning individual of the tournament (whether best or worst).
+  def produce(rng, candidates)
+    tournament = candidates.sample(@size, random: rng)
+    return @winning_condition ? tournament.min : tournament.max
+  end
+  
+end

data/lib/species/array_species.rb

@@ -0,0 +1,40 @@
+# Array-based species model their members as arrays of set values.
+class Wallace::Species::ArraySpecies < Wallace::Species
+
+  name = :array
+
+  # Constructs a new array-based species.
+  #
+  # *Parameters:*
+  # * opts, hash of keyword options used by this method.
+  #   -> id, the unique identifier for this species.
+  #   -> length, the length constraints imposed on individuals of this species.
+  #   -> values, the possible values of array elements (can be either a range or an array).
+  def initialize(opts = {})
+    super(opts)
+    @length = opts[:length]
+    @values = opts[:values]
+  end
+
+  # Check that a given individual meets the length constraints of the species.
+  def valid?(individual)
+    return false unless super(individual)
+    return true if @length.nil?
+    return false if @length.is_a? Integer and individual.data.length != @length
+    return false if @length.is_a? Range and (not @length.include? individual.data.length)
+  end
+
+  # Creates a new array-based individual using the set of values and length
+  # constraints of the species.
+  #
+  # *Parameters:*
+  # * opts, hash of keyword options used by this method.
+  #   -> random, the RNG to use when spawning individuals.
+  def spawn(opts = {})
+    opts[:random] ||= Random.new
+    size = @length.is_a?(Range) ? opts[:random].rand(@length) : @length
+    data = Array.new(size) { @values.sample(opts) }
+    return Wallace::Individual.new(self, data)
+  end
+
+end