nudge 0.0.1

data/lib/interpreter/types/pushTypes.rb

@@ -0,0 +1,102 @@
+# coding: utf-8
+
+class NudgeType
+  require 'singleton'
+  include Singleton
+  
+  @@all_types = []
+  
+  def self.inherited(subclass)
+    @@all_types << subclass
+    super
+  end
+  
+  def self.all_types
+    @@all_types
+  end
+  
+  def self.push_types
+    [IntType, BoolType, FloatType]
+  end
+  
+  def self.to_nudgecode
+    self.to_s.slice(0..-5).downcase
+  end
+  
+  def self.from_s
+    raise "Your subclass of NudgeType should provide a method for parsing string values in code"
+  end
+end
+
+
+
+
+class IntType < NudgeType
+  @defaultLowest = -100
+  @defaultHighest = 100
+  
+  def self.defaultLowest
+    @defaultLowest
+  end
+  
+  def self.defaultHighest
+    @defaultHighest
+  end
+  
+  def self.random_value(params={})
+    bottom = params[:randomIntegerLowerBound] || @defaultLowest
+    top = params[:randomIntegerUpperBound] || @defaultHighest
+    lowest, highest = [bottom,top].min, [bottom,top].max
+    rand(highest-lowest).to_i + lowest
+  end
+  
+  def self.from_s(string_value)
+    return string_value.to_i
+  end
+  
+  def self.any_value
+    self.random_value
+  end
+end
+
+
+
+
+class BoolType < NudgeType  
+  def self.random_value(params = {})
+    p = params[:randomBooleanTruthProb] || 0.5
+    rand() < p
+  end
+  
+  def self.from_s(string_value)
+    return string_value.downcase == "true"
+  end
+  
+  def self.any_value
+    self.random_value
+  end
+end
+
+
+
+
+class FloatType < NudgeType
+  @defaultLowest = -1000.0
+  @defaultHighest = 1000.0
+  
+  def self.random_value(params = {})
+    bottom = params[:randomFloatLowerBound] || @defaultLowest
+    top = params[:randomFloatUpperBound] || @defaultHighest
+    bottom, top = [bottom,top].min, [bottom,top].max
+    range = top - bottom
+    (rand*range) + bottom
+  end
+  
+  def self.from_s(string_value)
+    return string_value.to_f
+  end
+  
+  def self.any_value
+    self.random_value
+  end
+end

data/lib/nudge.rb

@@ -0,0 +1,38 @@
+$: << File.join(File.dirname(__FILE__), "/../lib") 
+
+require 'rubygems'
+require 'treetop'
+require 'polyglot'
+require 'active_support'
+require 'interpreter/grammars/nudge_language_helpers'
+require 'interpreter/grammars/nudge_language'
+require 'interpreter/interpreter'
+require 'interpreter/types/pushTypes'
+require 'interpreter/types/codeType'
+require 'interpreter/stack'
+require 'interpreter/programPoints'
+require 'search/helpers'
+
+require 'instructions/infrastructure'
+require 'instructions/stack_manipulation'
+require 'instructions/int_arithmetic'
+require 'instructions/float_arithmetic'
+require 'instructions/float_transcendental'
+require 'instructions/bool_basics'
+require 'instructions/comparisons'
+require 'instructions/conditionals'
+require 'instructions/conversions'
+require 'instructions/random_value'
+require 'instructions/exec'
+require 'instructions/name_bindings'
+require 'instructions/name_basics'
+require 'instructions/code_basics'
+
+
+require 'search/individual/individual'
+require 'search/individual/batch'
+require 'search/operators/basic_operators'
+require 'search/operators/samplers_and_selectors'
+require 'search/operators/evaluators'
+require 'search/stations/station'
+require 'search/experiments/experiment'

data/lib/search/experiments/experiment.rb

@@ -0,0 +1,53 @@
+module Nudge
+  require 'open-uri'
+  
+  class Experiment
+    attr_reader :name
+    attr_accessor :config
+    attr_accessor :couch_url
+    attr_accessor :instructions, :types, :variable_names
+    attr_accessor :station_names, :objectives
+    
+    def initialize(options = {})
+      @name = options[:name] || 'default_experiment'
+      @config = Nudge::Config.new
+      @instructions = Instruction.all_instructions
+      @types = [BoolType, FloatType, IntType]
+      @variable_names = []
+      
+      # paths
+      @couch_url = options[:couch_url] || 'http://localhost:5984'
+      
+      # infrastructure
+      @station_names = []
+      @objectives = {}
+      
+      Nudge::Config.stored_state.call(self) unless !Config.stored_state
+    end
+    
+    def build_station(name, params = {})
+      new_s = Station.new(name, params)
+      self.station_names << new_s.name
+    end
+    
+    def station_known?(name)
+      return @station_names.include?(name)
+    end
+    
+    def couch_live?
+      begin
+        ack = (open(@couch_url) {|db| db.status[0]} == "200")
+      rescue SocketError # there may be more exceptions to catch!
+        ack = false
+      end
+      return ack
+    end
+    
+    def connect_stations(flow_from, flow_to)
+      raise ArgumentError, "Unknown station: #{flow_from}" if !station_known?(flow_from)
+      raise ArgumentError, "Unknown station: #{flow_from}" if !station_known?(flow_to)
+      Station.stations[flow_from].flows_into Station.stations[flow_to]
+    end
+    
+  end
+end

data/lib/search/helpers.rb

@@ -0,0 +1,22 @@
+module Nudge
+  class InterpreterSettings
+    attr_accessor :instructions, :references, :types
+    
+    def initialize(params = {})
+      @instructions = params[:instructions] || Instruction.all_instructions 
+      @references = params[:references] || []
+      @types = params[:types] || NudgeType.push_types
+    end
+  end
+  
+  
+  class Config
+    def self.stored_state
+      @stored_state
+    end
+    
+    def self.setup(&block)
+      @stored_state = block
+    end
+  end
+end

data/lib/search/individual/batch.rb

@@ -0,0 +1,25 @@
+module Nudge
+  # A Batch is simply an Array of Individuals, with validation for all assignment methods
+  class Batch < Array
+    
+    def self.[](*args)
+      raise ArgumentError unless args.inject(true) {|anded, a| anded & a.kind_of?(Individual)}
+      super
+    end
+    
+    def []=(index, obj)
+      raise ArgumentError unless obj.kind_of?(Individual)
+      super
+    end
+    
+    def <<(obj)
+      raise ArgumentError unless obj.kind_of?(Individual)
+      super
+    end
+    
+    def initialize(*args)
+      raise ArgumentError unless args.inject(true) {|anded, a| anded & a.kind_of?(Individual)}
+      super
+    end
+  end
+end

data/lib/search/individual/individual.rb

@@ -0,0 +1,147 @@
+require 'couchrest'
+
+module Nudge
+  
+  class Individual
+    def self.helperParser
+      @helperParser ||= NudgeLanguageParser.new()
+    end
+    
+    def self.get(db_url, individual_id)
+      # connect
+      db = CouchRest.database!(db_url)
+      
+      # search
+      couchDoc = db.get(individual_id.to_s)
+      puts couchDoc
+      
+      # create new guy
+      newDude = self.new(couchDoc["genome"])
+      newDude.instance_variable_set('@id',couchDoc["_id"])
+      newDude.timestamp = couchDoc["creation_time"]
+      newDude.scores = couchDoc["scores"]
+      
+      return newDude
+    end
+      
+    attr_accessor :genome, :scores, :progress, :ancestors, :station, :program, :timestamp
+    attr_reader :id
+    
+    def initialize(listing)
+      @helperParser = 
+      
+      @genome = listing
+      raise(ArgumentError, "Nudge program cannot be parsed") if Individual.helperParser.parse(genome) == nil
+      @program = Individual.helperParser.parse(genome).to_points
+      @scores = Hash.new
+      @timestamp = Time.now.to_i
+      @progress = 0
+      @ancestors = []
+      @station = ""
+    end
+    
+    def known_scores
+      return self.scores.keys.sort
+    end
+    
+    def points
+      return self.program.points
+    end
+    
+    def score_vector(template = self.known_scores)
+      vector = []
+      template.each {|obj| vector << self.scores[obj]}
+      return vector
+    end
+    
+    
+    def dominated_by?(other, template = self.known_scores)
+      noWorse = true
+      somewhatBetter = false
+      template.each do |score|
+        if self.scores[score] && other.scores[score]
+          noWorse &&= (self.scores[score] >= other.scores[score])
+          somewhatBetter ||= (self.scores[score] > other.scores[score])
+        else
+          return false
+        end
+      end
+      return noWorse && somewhatBetter
+    end
+    
+    
+    def delete_point(which)
+      return self.program.listing if (which < 1 || which > self.program.points)
+      return "block {}" if which == 1
+      chunks = isolate_point(which)
+      variant = chunks[:left] + chunks[:right]
+      return variant
+    end
+    
+    
+    def replace_point(which, newCode = "")
+      raise(ArgumentError, "program points can only be replaced by nonempty strings") if newCode == ""
+      return self.program.listing if (which < 1 || which > self.program.points)
+      chunks = isolate_point(which)
+      variant =  (chunks[:left] || "") + " #{newCode} " + (chunks[:right] || "")
+      return variant
+    end
+    
+    
+    def isolate_point(which)
+      raise(ArgumentError, "point specified is out of range in this genome") if
+        (which < 1 || which > self.program.points)
+      result = {}
+      
+      # we're going to work in an array so we can do abacus-like manipulations
+      workingCopy = self.program.listing.split("\n")
+      posn = which - 1
+      
+      # look at the point itself now
+      # if it's a block, pull in more points from 'the right' until the braces balance here
+      if workingCopy[posn].include?("block")
+        leftCount = workingCopy[posn].count("{")
+        rightCount = workingCopy[posn].count("}")
+        while leftCount > rightCount do
+          workingCopy[posn] += (workingCopy[posn+1])
+          workingCopy.delete_at(posn+1)
+          leftCount = workingCopy[posn].count("{")
+          rightCount = workingCopy[posn].count("}")
+        end
+      end
+      
+      # whether the point is a block or not, we want to avoid taking extra closing braces
+      # so we will peel off extra right braces into new elements in our workingCopy array
+      leftCount = workingCopy[posn].count("{")
+      rightCount = workingCopy[posn].count("}")
+      while leftCount < rightCount do
+        workingCopy[posn] = workingCopy[posn].strip
+        workingCopy = workingCopy.insert(posn+1,"}")
+        workingCopy[posn] = workingCopy[posn].chomp("}")
+        leftCount = workingCopy[posn].count("{")
+        rightCount = workingCopy[posn].count("}")
+      end
+      
+      # we'll return an array of three strings
+      # everything in the genome to the left of the point
+      # the isolated point itself
+      # everything to the right of the point from the genome
+      # noting that if which==1, we will have empty left & right, and return the entire codeblock
+      result[:middle] = workingCopy[posn]
+      if which > 1
+        result[:left] = workingCopy[0..posn-1].join
+        result[:right] = workingCopy[posn+1..-1].join
+      end
+      return result
+    end
+    
+    def write
+      where = CouchRest.database!(@station.database)
+      response = where.save_doc({
+        "genome" => @genome,
+        "scores" => @scores,
+        "creation_time" => @timestamp})
+      @id = response["id"]
+    end
+  end
+end

data/lib/search/operators/basic_operators.rb

@@ -0,0 +1,230 @@
+module Nudge
+
+  # Abstract class that from which specific SearchOperator subclasses inherit initialization
+  
+  class SearchOperator
+    attr_accessor :params
+
+     def initialize(params={})
+       @params = params
+     end
+  end
+  
+  
+  
+  class RandomGuessOperator < SearchOperator
+    attr_accessor :context
+    
+    def initialize(params ={})
+      @context = InterpreterSettings.new(:instructions => params[:instructions],
+        :references => params[:references], :types => params[:types])
+      super
+    end
+    
+    # returns an Array of random Individuals
+    #
+    # the first (optional) parameter specifies how many to make, and defaults to 1
+    # the second (also optional) parameter is a hash or set of hash bindings that
+    # temporarily override those set in the initialization
+    #
+    # For example, if
+    # <tt>myRandomGuesser = RandomGuessOperator.new(:randomIntegerLowerBound => -90000)</tt>
+    #
+    # [<tt>myRandomGuesser.generate()</tt>]
+    #   produces a list of 1 Individual, and if it has any IntType samples they will be in [-90000,100]
+    #   (since the default +:randomIntegerLowerBound+ is 100)
+    # [<tt>myRandomGuesser.generate(1,:randomIntegerLowerBound => 0)</tt>]
+    #   makes one Individual whose IntType samples (if any) will be between [0,100]
+    
+    def generate(howMany = 1, tempParams ={})
+      result = Batch.new
+      howMany.times do
+        newGenome = CodeType.random_value(@context, @params.merge(tempParams))
+        newDude = Individual.new(newGenome)
+        newDude.progress = 0
+        result << newDude
+      end
+      result
+    end
+  end
+  
+  
+  class ResampleAndCloneOperator < SearchOperator
+    # returns an Array of clones of Individuals randomly selected from the crowd passed in
+    # 
+    # the first (required) parameter is an Array of Individuals
+    # the second (optional) parameter is how many samples to take, and defaults to 1
+    #
+    # For example, if
+    # <tt>@currentPopulation = [a list of 300 Individuals]</tt> and
+    # <tt>myRandomSampler = ResampleAndCloneOperator.new(@currentPopulation)</tt>
+    # [<tt>myRandomSampler.generate()</tt>]
+    #   produces a list of 1 Individual, which is a clone of somebody from <tt>@currentPopulation</tt>
+    # [<tt>myRandomGuesser.generate(11)</tt>]
+    #   returns a list of 11 Individuals cloned from <tt>@currentPopulation</tt>,
+    #   possibly including repeats
+    
+    def generate(crowd, howMany = 1)
+      result = Batch.new
+      howMany.times do
+        donor = crowd.sample
+        newGenome = donor.genome.clone
+        newDude = Individual.new(newGenome)
+        newDude.progress = donor.progress + 1
+        result << newDude
+      end
+      return result
+    end
+  end
+  
+  
+  class ResampleValuesOperator < SearchOperator
+    
+    # returns an Array of clones of Individuals randomly selected from the crowd passed in
+    #   the first (required) parameter is an Array of Individuals
+    #   the second (optional) parameter is how many samples to take, and defaults to 1
+    #
+    #   For example, if
+    #     @currentPopulation = [a list of 300 Individuals]
+    #     myRandomSampler = ResampleAndCloneOperator.new(@currentPopulation)
+    #     myRandomSampler.generate()::
+    #       produces a list of 1 Individual, which is a clone of somebody from @currentPopulation
+    #     myRandomGuesser.generate(11)::
+    #       returns a list of 11 Individuals cloned from @currentPopulation, possibly including repeats
+    
+    def generate(crowd, howManyCopies = 1, parameter_overrides = {})
+      crowd.each {|dude| raise(ArgumentError) if !dude.kind_of?(Individual) }
+      
+      result = Batch.new
+      tempParams = @params.merge(parameter_overrides)
+      crowd.each do |dude|
+        wildtype = dude.program.listing
+        howManyCopies.times do
+          novelty = ""
+          wildtype.each_line do |line|
+            line = line.sub(/\((.*)\)/,
+              "(#{IntType.random_value(tempParams)})") if line.include?("sample int")
+            line = line.sub(/\((.*)\)/,
+              "(#{BoolType.random_value(tempParams)})") if line.include?("sample bool")
+            line = line.sub(/\((.*)\)/,
+              "(#{FloatType.random_value(tempParams)})") if line.include?("sample float")
+            novelty << line
+          end
+          mutant = Individual.new(novelty)
+          mutant.progress = dude.progress + 1
+          result << mutant
+        end
+      end
+      result
+    end
+  end
+  
+  
+  
+  
+  class UniformBackboneCrossoverOperator < SearchOperator
+    def generate(crowd, howMany = crowd.length, prob = 0.5)
+      result = Batch.new
+      howMany.times do
+        where = rand(crowd.length)
+        mom = crowd[where]
+        dad = crowd[ (where+1) % crowd.length ]
+        xover = "block {\n"
+        (0..mom.program.contents.length-1).each do |point|
+          if rand() < prob
+            xover << mom.program.contents[point].tidy + "\n"
+          else
+            begin
+              xover << dad.program.contents[point].tidy + "\n"
+            rescue
+              xover << mom.program.contents[point].tidy + "\n"
+            end
+          end
+        end
+        xover << "}"
+        baby = Individual.new(xover)
+        baby.progress = [mom.progress,dad.progress].max + 1
+        
+        result << baby
+      end
+      return result
+    end
+  end
+  
+  
+  
+  class PointCrossoverOperator < SearchOperator
+    def generate(crowd, howManyBabies = 1)
+      raise(ArgumentError) if !crowd.kind_of?(Array)
+      raise(ArgumentError) if crowd.empty?
+      crowd.each {|dude| raise(ArgumentError) if !dude.kind_of?(Individual) }
+      
+      result = Batch.new
+      production = crowd.length*howManyBabies
+      production.times do
+        mom = crowd.sample
+        dad = crowd.sample
+        momSplit = mom.isolate_point(rand(mom.points)+1)
+        dadSplit = dad.isolate_point(rand(dad.points)+1)
+        babyGenome = (momSplit[:left] || "") + " #{dadSplit[:middle]} " + (momSplit[:right] || "")
+        baby = Individual.new(babyGenome)
+        baby.progress = [mom.progress,dad.progress].max + 1
+        result << baby
+      end
+      return result
+    end
+  end
+  
+  
+  
+  
+  class PointDeleteOperator < SearchOperator
+    def generate(crowd, howManyCopies = 1)
+      raise(ArgumentError) if !crowd.kind_of?(Array)
+      crowd.each {|dude| raise(ArgumentError) if !dude.kind_of?(Individual) }
+      
+      result = Batch.new
+      crowd.each do |dude|
+        howManyCopies.times do
+          where = rand(dude.points)+1
+          variant = dude.delete_point(where)
+          baby = Individual.new(variant)
+          baby.progress = dude.progress + 1
+          result << baby
+        end
+      end
+      return result
+    end
+  end
+  
+  
+  
+  class PointMutationOperator < SearchOperator
+    attr_accessor :context
+    
+    def initialize(params ={})
+      @context = InterpreterSettings.new(:instructions => params[:instructions],
+        :references => params[:references], :types => params[:types])
+      super
+    end
+    
+    def generate(crowd, howManyCopies = 1, tempParams ={})
+      raise(ArgumentError) if !crowd.kind_of?(Array)
+      raise(ArgumentError) if crowd.empty?
+      crowd.each {|dude| raise(ArgumentError) if !dude.kind_of?(Individual) }
+      
+      result = Batch.new
+      crowd.each do |dude|
+        howManyCopies.times do
+          where = rand(dude.points)+1
+          newCode = CodeType.random_value(@context, @params.merge(tempParams))
+          variant = dude.replace_point(where,newCode)
+          baby = Individual.new(variant)
+          baby.progress = dude.progress + 1
+          result << baby 
+        end
+      end
+      return result
+    end
+  end
+end