nudge 0.0.2 → 0.1.0

data/lib/interpreter/grammars/nudge_language.treetop

@@ -1,83 +0,0 @@
-grammar NudgeLanguage
-  
-  rule any_point
-    nonblock_point / block_point
-  end
-
-  rule block_point
-    spc? "block" spc* open_block innards:(any_point)* spc* close_block <BlockNode>
-  end
-  
-  rule nonblock_point
-    instruction_statement /
-    channel_statement /
-    literal_statement /
-    erc_statement
-  end
-  
-  rule instruction_statement
-    spc? "do" spc opcode:alpha_or_underscore spc* <InstructionNode>
-  end
-  
-  rule channel_statement
-    spc? "ref" spc chan_name:alpha_or_underscore spc* <ChannelNode>
-  end
-  
-  rule literal_statement
-    code_literal_statement / noncode_literal_statement
-  end
-  
-  rule noncode_literal_statement
-    spc? "literal" spc where:alpha_or_underscore spc* open_leaf assigned_value:most_anything close_leaf <LiteralNode>
-  end
-  
-  rule code_literal_statement
-    spc? "literal" spc where:"code" spc* open_leaf assigned_value:most_anything close_leaf <LiteralNode>
-  end
-  
-  rule erc_statement
-    code_literal_statement / noncode_erc_statement
-  end
-  
-  rule noncode_erc_statement
-    spc? "sample" spc where:alpha_or_underscore spc* open_leaf assigned_value:most_anything close_leaf <ERCNode>
-  end
-  
-  rule code_erc_statement
-    spc? "sample" spc where:"code" spc* open_leaf assigned_value:most_anything close_leaf <ERCNode>
-  end
-  
-  
-  rule comma
-    spc? "," spc?
-  end
-  
-  rule most_anything
-    (!')' . )*
-  end
-  
-  rule alpha_or_underscore
-    [a-zA-Z_] [a-zA-Z0-9_]*
-  end
-  
-  rule spc
-    [\s\t\n]+
-  end
-  
-  rule open_block
-    "{" spc?
-  end
-  
-  rule open_leaf
-    "(" spc?
-  end
-  
-  rule close_leaf
-    spc? ")" spc?
-  end
-  
-  rule close_block
-    spc? "}" spc?
-  end
-  
-end

data/lib/interpreter/grammars/nudge_language_helpers.rb

@@ -1,64 +0,0 @@
-# coding: utf-8
-module BlockNode
-  def to_points
-    newBlob = CodeBlock.new(text_value)
-    newBlob.contents = innards.elements.collect {|item| item.to_points}
-    newBlob.listing = newBlob.tidy
-    return newBlob
-  end
-end
-
-module InstructionNode
-  def instruction_name
-    return opcode.text_value
-  end
-  
-  def to_points
-    newBlob = InstructionPoint.new(opcode.text_value)
-    return newBlob
-  end
-end
-
-module ChannelNode
-  def channel_name
-    return chan_name.text_value
-  end
-  
-  def to_points
-    newBlob = ChannelPoint.new(channel_name)
-    return newBlob
-  end
-  
-end
-
-module LiteralNode
-  def stack_name
-    return where.text_value
-  end
-  
-  def value
-    # this depends on existence of class {stack_name}Literal with #build that returns
-    "#{stack_name.capitalize}Type".constantize.from_s(assigned_value.text_value)
-  end
-  
-  def to_points
-    newBlob = LiteralPoint.new(stack_name,value)
-    return newBlob
-  end
-end
-
-module ERCNode
-  def stack_name
-    return where.text_value
-  end
-  
-  def value
-    # this depends on existence of class {stack_name}Erc with #build that returns the value
-    "#{stack_name.capitalize}Type".constantize.from_s(assigned_value.text_value)
-  end
-  
-  def to_points
-    newBlob = Erc.new(stack_name,value)
-    return newBlob
-  end
-end

data/lib/search/experiments/experiment.rb

@@ -1,53 +0,0 @@
-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

@@ -1,22 +0,0 @@
-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

@@ -1,25 +0,0 @@
-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

@@ -1,145 +0,0 @@
-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

@@ -1,230 +0,0 @@
-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