wallace 0.0.0

data/lib/core/subpopulation.rb

@@ -0,0 +1,53 @@
+# This class is used to hold sub-populations of individuals. For at least
+# some length of time, subpopulations evolve independently, only interacting
+# with the rest of the population (other subpopulations) during migration.
+class Wallace::Subpopulation
+
+  attr_accessor :contents
+  attr_reader   :capacity,
+                :species
+
+  # Constructs a new subpopulation.
+  #
+  # *Arguments*
+  # * opts, a hash of keyword options for this method.
+  #   -> size, the size of this subpopulation.
+  #   -> species, the species of individuals within this sub-population.
+  def initialize(opts = {})
+    @capacity = opts[:size]
+    @contents = []
+    @species = opts[:species]
+  end
+
+  # Initialises a fresh sub-population of individuals.
+  #
+  # *Parameters:*
+  # * rng, the random number generator to use.
+  def fresh!(rng)
+    @contents = Array.new(@capacity) { @species.spawn(random: rng) }
+  end
+
+  # Clears the contents of this sub-population.
+  def clear!
+    @contents = []
+  end
+
+  # Returns the best individual within this sub-population.
+  def best
+    @contents.min
+  end
+  alias :min :best
+
+  # Returns the worst individual within this sub-population.
+  def worst
+    @contents.max
+  end
+  alias :max :worst
+
+  # Returns the actual number of individuals within this population.
+  def size
+    @contents.size
+  end
+  alias_method :length, :size
+
+end

data/lib/core/termination.rb

@@ -0,0 +1,39 @@
+# This class is used to store and check against the termination criteria of the evolutionary
+# process.
+class Wallace::Termination
+
+  attr_reader :generation_limit,
+              :stagnation_limit,
+              :fitness_limit,
+              :error
+
+  # Constructs a new termination criteria.
+  #
+  # *Parameters:*
+  # * opts, a hash of keyword options for this method.
+  #   -> generations, limit on the total number of generations to perform.
+  #   -> stagnation, limit on the successive number of generations without change to the best solution.
+  #   -> fitness, target fitness value.
+  #   -> error, the maximum allowed error in the target fitness value.
+  def initialize(opts = {})
+    @generation_limit = opts[:generations] || 200
+    @stagnation_limit = opts[:stagnation]
+    @fitness_limit = opts[:fitness]
+    @error = opts[:error] || 0
+  end
+
+  # Determines whether the evolutionary process has reached its termination
+  # criteria or not.
+  #
+  # *Parameters:*
+  # * state, the current state of the evolution.
+  #
+  # Returns true if it has finished and false if otherwise.
+  def finished?(state)
+    return true if not @generation_limit.nil? and state.generations == @generation_limit
+    return true if not @fitness_limit.nil? and state.best.fitness.value <= @fitness_limit + @error
+    return true if not @stagnation_limit.nil? and state.stagnation == @stagnation_limit
+    return false
+  end
+
+end

data/lib/distributions/gaussian_distribution.rb

@@ -0,0 +1,60 @@
+# Used to represent and sample values from a given Gaussian distribution.
+#
+# Uses the popular Box-Muller transformation to generate two values,
+# one of which is returned, the other which is cached (and returned
+# upon the next request).
+#
+# Since the Box-Muller transform samples two values from the distribution,
+# rather than discarding the extra value, we cache it and return it
+# upon the next request.
+#
+# *Credit to:*
+# http://stackoverflow.com/questions/5825680/code-to-generate-gaussian-normally-distributed-random-numbers-in-ruby
+class Wallace::Distributions::GaussianDistribution
+
+  # Constructs a new Gaussian distribution.
+  #
+  # *Parameters:*
+  # * mean, the mean of this distribution.
+  # * std_dev, the standard deviation of this distribution.
+  def initialize(mean, std_dev)
+    @mean = mean
+    @std_dev = std_dev
+    @cached = nil
+  end
+
+  # Samples a value from this distribution.
+  #
+  # Uses the popular Box-Muller transformation to generate two values,
+  # one of which is returned, the other which is cached (and returned
+  # upon the next request).
+  #
+  # *Parameters:*
+  # * opts, keyword arguments for this method.
+  # * -> random, the random number generation to use to seed the selection process.
+  def sample(opts = {})
+
+    # Create a RNG if one isn't already provided.
+    random = opts[:random] || Random.new
+
+    # Return a cached value if there is one.
+    # We could collapse these 4 lines into a much nicer:
+    # return @values.pop if @values.empty?
+    # However .empty? is much more expensive!
+    unless @cached.nil?
+      value = @cached
+      @cached = nil
+      return value
+    end
+
+    # Otherwise calculate two new values, caching one and
+    # returning the other.
+    theta = 2 * Math::PI * random.rand
+    rho = Math.sqrt(-2 * Math.log(1 - random.rand))
+    scale = @std_dev * rho
+    @cached = @mean + scale * Math.cos(theta)
+    return @mean + scale * Math.sin(theta)
+    
+  end
+
+end

data/lib/distributions/init.rb

@@ -0,0 +1,3 @@
+module Wallace::Distributions; end
+
+require_relative 'gaussian_distribution.rb'

data/lib/fitness/init.rb

@@ -0,0 +1 @@
+require_relative 'raw_fitness.rb'

data/lib/fitness/raw_fitness.rb

@@ -0,0 +1,30 @@
+# The raw fitness model uses a single numeric type to describe the fitness of a given individual.
+# Ordering of fitnesses, and thus of individuals, is achieved via ordering on these simple numeric
+# types.
+class Wallace::Fitness::RawFitness < Wallace::Fitness
+
+  # Allow the fitness value to be read but not changed.
+  attr_reader :value
+
+  # Constructs a new raw fitness.
+  #
+  # *Parameters:*
+  # * value, the raw fitness value.
+  def initialize(value)
+    @value = value
+  end
+
+  # Compares this raw fitness to another.
+  #
+  # *Parameters:*
+  # * other, the fitness to compare against.
+  #
+  # *Warning:*
+  # It is assumed that a RawFitness object is provided for comparison.
+  def <=>(other)
+    return -1 if other.value.is_a? Float and other.value.nan?
+    return 1 if @value.is_a? Float and @value.nan?
+    return @value <=> other.value
+  end
+
+end

data/lib/loggers/csv_logger.rb

@@ -0,0 +1,20 @@
+# The CSV logger records information in a 
+class Wallace::Loggers::CsvLogger < Wallace::Logger
+
+  # Constructs a new CSV logger.
+  #
+  # *Parameters:*
+  # * file, the CSV file to log to.
+  # * opts, a hash of keyword options for this logger.
+  #   -> columns, an ordered list of columns in this CSV.
+  #   -> headers, an optional hash of headers for the columns in the CSV file.
+  def initialize(file)
+
+  end
+
+  
+  def write(data)
+
+  end
+
+end

data/lib/loggers/init.rb

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

data/lib/loggers/mongo_logger.rb

@@ -0,0 +1,5 @@
+class Wallace::Loggers::MongoLogger < Wallace::Logger
+
+  
+
+end

data/lib/loggers/sqlite_logger.rb

@@ -0,0 +1,5 @@
+class Wallace::Loggers::SQLiteLogger < Wallace::Logger
+
+  
+
+end

data/lib/modules/ge/backus_naur_form.rb

@@ -0,0 +1,125 @@
+# Used to hold token values.
+Wallace::GE::Literal = Struct.new(:value)
+Wallace::GE::Symbol = Struct.new(:value)
+
+# This class holds the details of a BNF grammar and provides methods for producing
+# a derivation from a given sequence of integers.
+#
+# Rather than having a special class for grammar sequences, we simply use arrays to
+# store grammar sequences, ensuring the best possible compatibility with existing
+# array-based operators.
+class Wallace::GE::BackusNaurForm
+
+  # The root symbol for this grammar (where all derivations begin).
+  attr_reader :root
+
+  # Constructs a new BNF Grammar.
+  #
+  # *Parameters:*
+  # * root, the root symbol in the grammar (at which all derivations start).
+  # * rules, the rules of this grammar, given as a hash, indexed by symbol.
+  def initialize(root, rules)
+
+    # Convert each rule into a sequence of symbol derivations.
+    # Transform each string-based derivation into a sequence of tokens.
+    @rules = Hash[rules.map { |rule, derivations|
+      derivations.map! { |derivation|
+        tokens = []
+        until derivation.empty?
+          left, tag, right = derivation.partition(/{\w+}/)
+          tokens << Wallace::GE::Literal.new(left) unless left.empty?
+          tokens << Wallace::GE::Symbol.new(tag[1...tag.length-1]) unless tag.empty?
+          derivation = right
+        end
+        tokens
+      }
+      [rule.to_s, derivations]
+    }].freeze
+
+    # Could ensure that the root is a valid symbol.
+    @root = root.to_s.freeze
+
+  end
+
+  # Returns the number of symbols in the BNF.
+  def size
+    @rules.size
+  end
+  alias :length :size
+
+  # Returns the list of possible derivations for a given symbol.
+  def [](symbol)
+    @rules[symbol]
+  end
+  alias :derivations :[]
+
+  # Produces a grammar derivation from a given sequence of integers.
+  #
+  # *Parameters:*
+  # * sequence, the sequence of integers to produce a derivation from.
+  # * opts, a hash of keyword options for this method.
+  #   -> random, the RNG to use during the derivation process.
+  #   -> wrap, flag indicating whether the sequence should be wrapped when
+  #      all genetic material has been used.
+  #   -> max_wraps, the maximum number of times the sequence should be
+  #      wrapped.
+  #
+  # *Returns:*
+  # A grammar derivation object for the produced derivation.
+  def derive(sequence, opts = {})
+
+    # For now wrapping is forced.
+    opts[:wrap] = true
+    opts[:max_wraps] ||= 1 if opts[:wrap]
+
+    derivation = Wallace::GE::GrammarDerivation.new
+
+    # Keep processing the sequence of tokens until none remain.
+    #
+    # * Literal tokens are appended to the end of the derivation.
+    # * Symbol tokens are converted into a given symbol derivation,
+    #   using the next codon as the index if there is more than a single
+    #   choice.
+    # * When there are no codons left to consume then we either:
+    #   a) Add a new codon to the sequence (until the limit is reached). [DISABLED]
+    #   b) Reset the codon index to zero, wrapping the sequence round.
+    queue = [Wallace::GE::Symbol.new(@root)]
+    codon_index = 0
+    sequence_length = sequence.length
+    num_wraps = 0
+
+    until queue.empty?
+      token = queue.shift
+      if token.is_a? Wallace::GE::Literal
+        derivation << token.value
+      else
+        options = @rules[token.value]
+        if options.length == 1
+          queue += options[0]
+        else
+
+          # Check if there are no remaining codons in the sequence.
+          if (codon_index >= sequence_length)
+
+            # If wrapping is enabled, reset the codon pointer to the
+            # start of the sequence, unless the maximum number of wraps
+            # has been encountered.
+            if opts[:wrap]
+              raise Wallace::Errors::GenotypeExhaustedError if num_wraps != opts[:max_wraps] # throw error?
+              codon_index = 0
+              num_wraps += 1
+            end
+
+          end
+
+          queue = options[sequence[codon_index] % options.length] + queue
+          codon_index += 1
+        end
+      end
+    end
+
+    return derivation.freeze
+
+  end
+
+end

data/lib/modules/ge/grammar_derivation.rb

@@ -0,0 +1,30 @@
+# The GrammarDerivation class is used to hold a derivation of a grammar produced by some provided
+# sequence of integers. This class implements methods for transforming the derivation into other
+# forms.
+class Wallace::GE::GrammarDerivation < String
+
+  # Produces a lambda function from a given grammar derivation and a set
+  # of arguments.
+  #
+  # *Parameters:*
+  # * args, an ordered array of the arguments to the lambda function.
+  # * derivation, the grammar derivation to use as the body of the function.
+  #
+  # *Returns:*
+  # The corresponding lambda function.
+  def self.to_lambda(args, derivation)
+    eval("lambda { |#{args.join(',')}| #{derivation} }")
+  end
+
+  # Converts this derivation into a usable lambda function.
+  #
+  # *Parameters:*
+  # * args, an ordered array of the arguments to the lambda function.
+  #
+  # *Returns:*
+  # The corresponding lambda function.
+  def to_lambda(args)
+    Wallace::GE::GrammarDerivation.to_lambda(args, self)
+  end
+
+end

data/lib/modules/ge/grammar_species.rb

@@ -0,0 +1,29 @@
+# The grammar species represents each individual in the species as an array of integers which
+# map to a derivation of the grammar attached to the species.
+class Wallace::GE::GrammarSpecies < Wallace::Species::ArraySpecies
+
+  name = :grammar
+
+  attr_reader :grammar
+
+  # Constructs a new grammar-based species.
+  #
+  # *Parameters:*
+  # * opts, hash of keyword options used by this method.
+  #   -> id, the unique identifier for this species.
+  #   -> grammar, the grammar used by individuals of this species.
+  #   -> length, the length constraints on individuals of the species.
+  def initialize(opts = {})
+
+    # By default grammar derivations are between 10 and 200 symbols and contain
+    # integers in the range 0 to 2147483647 inclusive.
+    opts[:length] ||= 10..200
+    opts[:values] ||= 0..2147483647
+    
+    super(opts)
+
+    @grammar = opts[:grammar]
+
+  end
+
+end

data/lib/modules/ge/init.rb

@@ -0,0 +1,5 @@
+module Wallace::GE; end
+
+require_relative 'backus_naur_form.rb'
+require_relative 'grammar_species.rb'
+require_relative 'grammar_derivation.rb'

data/lib/modules/init.rb

@@ -0,0 +1,2 @@
+require_relative 'koza/init.rb'
+require_relative 'ge/init.rb'

data/lib/modules/koza/builder.rb

@@ -0,0 +1,48 @@
+# The base class used by all Koza tree builders.
+class Wallace::Koza::Builder
+
+  # The range of depths that trees within this species may have.
+  attr_accessor :depth_limits
+
+  attr_reader :terminals,
+              :non_terminals
+
+  # Prepares the builder.
+  #
+  # *Parameters:*
+  # * terminals, the list of terminals.
+  # * non_terminals, the list of non-terminals.
+  # * depth_limits, the range of depths that trees within the species may have.
+  def prepare(terminals, non_terminals, depth_limits)
+    @terminals = terminals
+    @non_terminals = non_terminals
+    @depth_limits = depth_limits
+  end
+
+  # Builds a new tree according to this build method that meets the depth
+  # constraints of the species.
+  #
+  # *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 = {})
+    raise NotImplementedError, 'No "build_tree" function was implemented by this builder.'
+  end
+
+  # Builds a new subtree of a maximum given 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.
+  def build_subtree(max_depth, opts = {})
+    raise NotImplementedError, 'No "build_subtree" function was implemented by this builder.'
+  end
+
+end