wallace 0.0.0

data/lib/operators/gaussian_mutation_operation.rb

@@ -0,0 +1,39 @@
+# The Gaussian mutation operator mutates the genes of an individual with a given
+# probability (mutation rate)
+class Wallace::Operators::GaussianMutationOperator < Wallace::Operator
+
+  name = :gaussian_mutation
+
+  # Allow the mutation probability to be dynamically adjusted.
+  attr_accessor :probability
+
+  # Allow the distribution to be dynamically adjusted.
+  attr_accessor :distribution
+
+  # Constructs a new gaussian 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).
+  #   -> distribution, the gaussian distribution which should be used.
+  #   -> bounds, the bounds for all genes in the chromosome.
+  def initialize(opts = {})
+    super(opts)
+    @probability = opts[:probability] || 0.01
+    @distribution = opts[:distribution]
+    @bounds = opts[:bounds]
+  end
+
+  def operate(rng, inputs)
+    (0...inputs[0].length).each do |i|
+      if rng.rand <= @probability
+        inputs[0][i] += @distribution.sample(random: rng)
+        inputs[0][i] = [@bounds.first, inputs[0][i], @bounds.last].sort[1] unless @bounds.nil?
+      end
+    end
+    return inputs
+  end
+
+end

data/lib/operators/half_uniform_crossover_operation.rb

@@ -0,0 +1,24 @@
+# Half uniform crossover takes two individuals as parents, A and B, and produces two children, C and D,
+# by swapping exactly half of their non-matching bits.
+class Wallace::Operators::HalfUniformCrossoverOperator < Wallace::Operator
+
+  name = :half_uniform_crossover
+
+  def operate(rng, inputs)
+
+    # Find all indices where bits do not match between A and B.
+    indices = []
+    (0...inputs[0].length).each do |i|
+      indices << i if inputs[0][i] != inputs[1][i]
+    end
+
+    # Swap exactly half of the non-matching bits.
+    indices.shuffle(random: rng).first((indices.length/2).to_i).each do |i|
+      inputs[0][i], inputs[1][i] = inputs[1][i], inputs[0][i]
+    end
+
+    return inputs
+
+  end
+
+end

data/lib/operators/init.rb

@@ -0,0 +1,26 @@
+module Wallace::Operators; end
+
+require_relative 'boundary_mutation_operation.rb'
+require_relative 'uniform_mutation_operation.rb'
+require_relative 'point_mutation_operation.rb'
+require_relative 'bit_flip_mutation_operation.rb'
+require_relative 'twors_mutation_operation.rb'
+require_relative 'reverse_sequence_mutation_operation.rb'
+require_relative 'gaussian_mutation_operation.rb'
+require_relative 'shuffle_mutation_operation.rb'
+require_relative 'swap_mutation_operation.rb'
+
+require_relative 'one_point_crossover_operation.rb'
+require_relative 'two_point_crossover_operation.rb'
+require_relative 'uniform_crossover_operation.rb'
+require_relative 'half_uniform_crossover_operation.rb'
+require_relative 'three_parent_crossover_operation.rb'
+require_relative 'splice_crossover_operation.rb'
+require_relative 'variable_one_point_crossover_operation.rb'
+
+require_relative 'cycle_crossover_operation.rb'
+require_relative 'merging_crossover_operation.rb'
+require_relative 'partially_mapped_crossover_operation.rb'
+require_relative 'order_crossover_operation.rb'
+require_relative 'position_crossover_operation.rb'
+require_relative 'subtour_exchange_crossover_operation.rb'

data/lib/operators/merging_crossover_operation.rb

@@ -0,0 +1,27 @@
+# Merging crossover takes two parents as input and randomly merges their chromosomes into
+# a dual-length chromosome, randomly choosing between each parent when adding each gene.
+#
+# The merged chromosome is then split into two child chromosomes by using the first occurrence
+# of each allele as the order of genes in the first child, and the second occurence as the
+# order of genes in the second child.
+class Wallace::Operators::MergingCrossoverOperator < Wallace::Operator
+
+  name = :merging_crossover
+
+  def operate(rng, inputs)
+
+    # Rather than progressively building up the merged chromosome, we can quickly
+    # add the two parent chromosomes together and shuffle the resulting sequence.
+    merged_chromosome = (inputs[0] + inputs[1]).shuffle(random: rng)
+
+    # Split the merged chromosome into two child chromosomes.
+    # We check whether it is the first occurence of a given allele by seeing if the
+    # allele exists within the first child's chromosome.
+    child_chromosomes = [ [], [] ]
+    merged_chromosome.each { |g| child_chromosomes[(child_chromosomes[0].include? g) ? 1 : 0] << g }
+
+    return child_chromosomes
+
+  end
+
+end

data/lib/operators/one_point_crossover_operation.rb

@@ -0,0 +1,29 @@
+# One-point crossover (also known as single-point crossover) takes two individuals, A and B, as parents,
+# and produces two children, formed by the combination of sub-strings from A and B.
+#
+# Firstly a single crossover point, common to the two individuals is selected, effectively splitting each
+# parent, A and B, into two substrings (A1, A2; B1, B2). The resulting substrings (A1+B2 and B1+A2) are
+# combined to form two (potentially) unique children.
+class Wallace::Operators::OnePointCrossoverOperator < Wallace::Operator
+
+  name = :one_point_crossover
+
+  def operate(rng, inputs)
+
+    a, b = individuals
+
+    # Ensure that the individuals are longer than length 1!
+    return inputs if inputs[0].length <= 1 or inputs[1].length <= 1
+
+    # Calculate the crossover point, split A and B into four substrings
+    # and combine those substrings to form two children. 
+    x = rng.rand((1...([inputs[0].length, inputs[1].length].min)))
+    
+    return [
+      inputs[0][0...x] + inputs[0][x...inputs[0].length],
+      inputs[1][0...x] + inputs[1][x...inputs[1].length]
+    ]
+
+  end
+
+end

data/lib/operators/order_crossover_operation.rb

@@ -0,0 +1,38 @@
+# The order crossover operator takes two parents as input and creates two offspring.
+#
+# Two random crossover points on the chromosome (the same for each parent) are selected
+# and the genes at all loci in between are carried to each child (i.e. P0 -> C0, P1 -> C1).
+#
+# The remaining genes of each child are determined by inserting all genes that are not covered
+# within their central subsequence (copied from the parent) in the order that they appear in the
+# other parent. Once the order of genes has been calculated, the genes are inserted after the
+# second crossover point and are wrapped around the start and to the first crossover point.
+class Wallace::Operators::OrderCrossoverOperator < Wallace::Operator
+
+  name = :order_crossover
+
+  def operate(rng, inputs)
+
+    # Select two random crossover points.
+    # All genes between these points are left untouched.
+    len = inputs[0].length
+    i, j = Array.new(2) { rng.rand(len - 1) }.sort
+
+    # Find the alleles that are not within the selected subsequence of each
+    # parent in the order of the other parents chromosome.
+    insert = Array.new(2) do |input|
+      inputs[(input+1)%2].select { |g| inputs[input][i..j].exclude? g }
+    end
+
+    # Inject the alleles in the gathered order starting at the second
+    # crossover point before wrapping around to the first.
+    (0..1).each do |input|
+      inputs[input][j+1...len] = insert[input].shift(len-j-1)
+      inputs[input][0...i] = insert[input]
+    end
+
+    return inputs
+
+  end
+
+end

data/lib/operators/partially_mapped_crossover_operation.rb

@@ -0,0 +1,44 @@
+# The partially mapped crossover swaps a single genetic subsequence (at the same position) between
+# two parents before fixing any resulting collisions by calculating and applying partial mappings
+# on damaged genes.
+class Wallace::Operators::PartiallyMappedCrossoverOperator < Wallace::Operator
+
+  name = :partially_mapped_crossover
+
+  def operate(rng, inputs)
+
+    # Select two random crossover points.
+    len = inputs[0].length
+    i, j = Array.new(2) { rng.rand(len - 1) }.sort
+
+    # Exchange the gene sequence of the two parents between these points
+    # to form two proto-children (which may break the chromosome).
+    inputs[0][i..j], inputs[1][i..j] = inputs[1][i..j], inputs[0][i..j]
+
+    # To fix the proto-children we map any alleles which occur outside of
+    # the exchanged sub-sequence with their counterpart in the partial map.
+    mapping = Hash[(inputs[0][i..j] + inputs[1][i..j]).map { |a| [a, []] }]
+    (i..j).each do |g|
+      mapping[inputs[0][g]] << inputs[1][g]
+      mapping[inputs[1][g]] << inputs[0][g]
+    end
+
+    # Fix all allele collisions via the map.
+    inputs.each do |input|
+      [(0...i), (j+1...len)].each do |sub|
+        sub.each do |g|
+          a = input[g]
+          last = nil
+          while input[i..j].include? a
+            input[g] = (last.nil? or (mapping[a][0] != last)) ? mapping[a][0] : mapping[a][1]
+            a, last = input[g], a
+          end
+        end
+      end
+    end
+
+    return inputs
+
+  end
+
+end

data/lib/operators/point_mutation_operation.rb

@@ -0,0 +1,31 @@
+# Point mutation selects a prespecified number of points of a provided chromosome at
+# random and replaces them with a value sampled from the provided distribution.
+class Wallace::Operators::PointMutationOperator < Wallace::Operator
+
+  name = :point_mutation
+
+  # Allow the number of points to be dynamically adjusted.
+  attr_accessor :points
+
+  # Constructs a new point 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). 
+  #   -> points, the number of points which should be mutated. (default = 1).
+  def initialize(opts = {})
+    super(opts)
+    @values = opts[:values] # could gather this information from the species?
+    @points = opts[:points] || 1
+  end
+
+  def operate(rng, inputs)
+    (0...inputs[0].length).to_a.sample(@points).each do |i|
+      inputs[0][i] = @values.sample(random: rng)
+    end
+    return inputs
+  end
+
+end

data/lib/operators/position_crossover_operation.rb

@@ -0,0 +1,50 @@
+# The position crossover operator takes two parents as input and creates two offspring.
+#
+# A random number of loci are selected from the first parent and all genes at those loci
+# are copied to the corresponding proto-children of each parent.
+#
+# The remaining genes are determined by finding the order of the remaining alleles
+# (those not contained at the randomly selected loci) in the opposite parent and inserting
+# them into the chromosome slots in that given order.
+class Wallace::Operators::PositionCrossoverOperator < Wallace::Operator
+
+  name = :position_crossover
+
+  def operate(rng, inputs)
+
+    # Select a random number of loci to fix the alleles at.
+    len = inputs[0].length
+    loci = (0...len).to_a.sample(rng.rand(1...len), random: rng)
+
+    # Generate the proto-children by copying the alleles at
+    # the selected loci.
+    #
+    # Rather than having the alleles array we could just check the
+    # child arrays. This would be less code, but there may be a lot
+    # of null placeholder values so the look-up will take longer.
+    children = Array.new(2) { Array.new(len) { nil } }
+    alleles = [[],[]]
+    loci.each do |i|
+      alleles[0] << inputs[0][i]
+      alleles[1] << inputs[1][i]
+      children[0][i] = inputs[0][i]
+      children[1][i] = inputs[1][i]
+    end
+
+    # Determine the order of the remaining alleles from the
+    # opposite parent for each protochild.
+    alleles.each_index do |i|
+      alleles[i] = inputs[(i+1)%2].select { |a| alleles[i].exclude? a }
+    end
+
+    # Fill the remaining loci of each chromosome using the
+    # determined order.
+    children.each_index do |c|
+      children[c].map! { |g| g.nil? ? alleles[c].shift : g}
+    end
+
+    return children
+
+  end
+
+end

data/lib/operators/reverse_sequence_mutation_operation.rb

@@ -0,0 +1,13 @@
+# The reverse sequence mutation operator takes an individual and reverses the order of
+# all its genes between two loci i and j, where i < j.
+class Wallace::Operators::ReverseSequenceMutationOperator < Wallace::Operator
+
+  name = :reverse_sequence_mutation
+
+  def operate(rng, inputs)
+    i, j = (0...inputs[0].length).to_a.sample(2).sort
+    inputs[0][i..j] = inputs[0][i..j].reverse
+    return inputs
+  end
+
+end

data/lib/operators/shuffle_mutation_operation.rb

@@ -0,0 +1,17 @@
+# Shuffle mutation selects a random continuous series of genes in the chromosome
+# and shuffles the order of gene values at random. 
+class Wallace::Operators::ShuffleMutationOperator < Wallace::Operator
+
+  name = :shuffle_mutation
+
+  def operate(rng, inputs)
+
+    # Shuffle the gene sequence between points i and j, where i < j. 
+    i = rng.rand(inputs[0].length - 2)
+    j = rng.rand(i...inputs[0].length)
+    inputs[0][i..j] = inputs[0][i..j].shuffle(random: rng)
+    return inputs
+
+  end
+
+end

data/lib/operators/splice_crossover_operation.rb

@@ -0,0 +1,42 @@
+# The splice crossover operator takes two parents (which may have different length genomes), splits each
+# into two substrings at random points (using a different point for each parent) before combining
+# the four substrings into a pair of two substrings at random to produce two children.
+class Wallace::Operators::SpliceCrossoverOperator < Wallace::Operator
+
+  name = :splice_crossover
+
+  def operate(rng, inputs)
+
+    # Do nothing if either string is shorter than length 2.
+    return inputs if inputs[0].length <= 1 or inputs[1].length <= 1
+
+    # Cut the two strings into four strings at a random
+    # point such that the recombination of any two strings will result in
+    # a legal string (a string whose length does not exceed the bounds).
+    x, y = rng.rand(1...inputs[0].length), rng.rand(1...inputs[1].length)
+    strings = [
+      inputs[0][0...x],
+      inputs[1][0...y],
+      inputs[0][x...inputs[0].length],
+      inputs[1][y...inputs[1].length]
+    ]
+
+    # given any A, B, C and D, it is given that:
+    # min <= #(A+B) <= max
+    # min <= #(C+D) <= max
+
+    # we want to find an A, B, C, D, such that:
+    # min <= #(A+D) <= max
+    # min <= #(C+B) <= max
+
+    # Randomly re-attach the four strings into two strings
+    # and return the resulting individuals.
+    strings.shuffle!(random: rng)
+    return [
+      strings.pop + strings.pop,
+      strings.pop + strings.pop
+    ]
+    
+  end
+
+end

data/lib/operators/subtour_exchange_crossover_operation.rb

@@ -0,0 +1,54 @@
+# INCREDIBLY SLOW! O(n^3)
+class Wallace::Operators::SubtourExchangeCrossoverOperator < Wallace::Operator
+
+  name = :subtour_exchange_crossover
+
+  # The Subtour data structure is used to hold a given subtour along
+  # with its start and end position within the whole tour (i.e.
+  # the bounds of the subtour).
+  Subtour = Struct.new(:tour, :bounds)
+
+  def operate(rng, inputs)
+
+    # Calculate the set of all subtours within each parent
+    # chromosome that are greater than length 1 and shorter
+    # than the entire tour length.
+    len = inputs[0].length
+    subtours = (0..1).map do |input|
+      Hash[(2...len).map { |k|
+        [k, (0...len).cons(k).map { |bounds|
+          bounds = bounds.first..bounds.last
+          Subtour.new(inputs[input][bounds], bounds)
+        }]
+      }]
+    end
+
+    # Check each k-length subtour for the same vertices.
+    subtours = Hash[(2...len).map { |k|
+      [ k,
+        subtours[0][k].product(subtours[1][k]).select { |s1, s2|
+          s1.tour - s2.tour == s2.tour - s1.tour
+        }]
+    }]
+
+    # Reduce the set of sub-tours to a non-overlapping set.
+    # (i.e. there are no (k-1)-length tours contained within a k-length tour).
+    #
+    # Alternatively we could perform replacements in ascending order
+    # of subtour length. Simpler and gives the same result, but more replacements
+    # are performed; is there much of a performance gain from pre-processing the
+    # set of candidate subtours?
+    #
+    # For now we will stick to the latter for the sake of simplicity.
+    subtours.each_value do |k_subtours|
+      k_subtours.each do |s1, s2|
+        inputs[0][s1.bounds] = s2.tour
+        inputs[1][s2.bounds] = s1.tour
+      end
+    end
+
+    return inputs
+
+  end
+
+end