nudge 0.0.1

data/lib/search/operators/evaluators.rb

@@ -0,0 +1,107 @@
+module Nudge
+  
+  class Evaluator < SearchOperator
+    attr_accessor :name
+    
+    def initialize(params = {})
+      raise(ArgumentError, "Evaluators must be initialized with names") if params[:name] == nil
+      @name = params[:name]
+    end
+  end
+  
+  
+  
+  
+  
+  class ProgramPointEvaluator < Evaluator
+    def evaluate(batch)
+      raise(ArgumentError, "Can only evaluate a Batch of Individuals") if !batch.kind_of?(Batch)
+      batch.each {|i| i.scores[@name] = i.points}
+    end
+  end
+  
+  
+  
+  
+  
+  class TestCase
+    attr_accessor :bindings, :expectations, :gauges
+    
+    def initialize(args = {})
+      @bindings = args[:bindings] || Hash.new
+      @expectations = args[:expectations] || Hash.new
+      @gauges = args[:gauges] || Hash.new
+      
+      if (@expectations.keys - @gauges.keys).length > 0
+        raise ArgumentError, "One or more expectations have no defined gauge"
+      end
+    end
+  end
+  
+  
+  
+  
+  
+  class TestCaseEvaluator < Evaluator
+    attr_accessor :interpreter_settings
+    
+    def evaluate(batch, cases = [], params = {})
+      raise(ArgumentError, "Can only evaluate a Batch of Individuals") if !batch.kind_of?(Batch)
+      
+      instructions = params[:instructions] || Instruction.all_instructions
+      types = params[:types] || [IntType, BoolType, FloatType]
+      variable_names = params[:references] || []
+      
+      batch.each do |dude|
+        if !params[:deterministic] || !dude.scores[@name]
+          score = 0
+          readings = {}
+          cases.each do |example|
+            difference = 0
+          
+            # make an Interpreter
+            workspace = Interpreter.new(
+              :instructions => instructions,
+              :types => types,
+              :references => variable_names)
+          
+            # set up the program
+            workspace.reset(dude.genome)
+          
+            # set up the bindings
+            example.bindings.each do |key,value|
+              workspace.bind_variable(key, value)
+            end
+          
+            # run it
+            workspace.run
+          
+            # apply the gauge(s) for each expectation
+            example.gauges.each do |variable_name,the_gauge|
+              readings[variable_name] = the_gauge.call(workspace)
+            end
+          
+            # synthesize readings into a single scalar difference
+            # FIXME this should be a settable Proc
+            example.gauges.each do |variable_name,the_gauge|
+              begin
+                difference = (readings[variable_name].value - example.expectations[variable_name])
+              rescue
+                difference = 100000
+              end
+            end
+          
+            score += difference.abs
+          end
+          # aggregate differences
+          dude.scores[@name] = score.to_f / cases.length
+        
+          puts "#{score.to_f / cases.length}" if params[:feedback]
+        else
+          puts dude.scores[@name] if params[:feedback]
+        end
+      end
+    end
+    
+  end
+end

data/lib/search/operators/samplers_and_selectors.rb

@@ -0,0 +1,123 @@
+module Nudge
+  
+  class Sampler < SearchOperator
+    def initialize (params = {})
+      super
+    end
+    
+    def all_known_scores(crowd)
+      union = []
+      crowd.each do |dude|
+        union |= dude.known_scores
+      end
+      return union
+    end
+    
+    
+    def all_shared_scores(crowd)
+      intersection = self.all_known_scores(crowd)
+      crowd.each do |dude|
+        intersection = intersection & dude.known_scores
+      end
+      return intersection
+    end
+    
+    
+    def domination_classes(crowd, template = all_shared_scores(crowd))
+      result = Hash.new()
+      crowd.each_index do |i|
+        dominatedBy = 0
+        crowd.each_index do |j|
+          dominatedBy += 1 if crowd[i].dominated_by?(crowd[j], template)
+        end
+        result[dominatedBy] ||= []
+        result[dominatedBy].push crowd[i]
+      end
+      return result
+    end
+    
+    
+    def diversity_classes(crowd)
+      result = Hash.new()
+      crowd.each do |dude|
+        result[dude.program.tidy] ||= []
+        result[dude.program.tidy] << dude
+      end
+      return result
+    end
+  end
+  
+  
+  class NondominatedSubsetSelector < Sampler
+    
+    def generate(crowd, template = all_shared_scores(crowd))
+      result = Batch.new
+      crowd.each do |dude|
+        dominated = false
+        crowd.each do |otherDude|
+          dominated ||= dude.dominated_by?(otherDude, template)
+        end
+        if !dominated
+          result << dude
+        end
+      end
+      return result
+    end
+  end
+  
+  
+  class DominatedQuantileSampler < Sampler
+    def generate(crowd, proportion = 0.5, template = all_shared_scores(crowd))
+      classified = domination_classes(crowd, template)
+      increasing_grades = classified.keys.sort {|a,b| b <=> a}
+      partial_ordering = []
+      increasing_grades.each {|grade| partial_ordering += classified[grade]}
+      how_many = crowd.length * proportion
+      
+      result = Batch.new
+      partial_ordering[0..how_many-1].each {|dude| result << dude} unless how_many == 0
+      return result
+    end
+  end
+  
+  
+  
+  
+  
+  class MostDominatedSubsetSampler < Sampler
+    def generate(crowd, template = all_shared_scores(crowd))
+      result = Batch.new
+      classified = domination_classes(crowd, template)
+      worst_key = classified.keys.sort[-1]
+      classified[worst_key].each {|bad_dude| result.push bad_dude}
+      return result
+    end
+  end
+  
+  
+  
+  
+  
+  class AnyOneSampler < Sampler
+    def generate(crowd)
+      result = Batch[crowd.sample]
+    end
+  end
+  
+  
+  
+  
+  
+  class AllDuplicatedGenomesSampler < Sampler
+    def generate(crowd)
+      result = Batch.new
+      clustered = diversity_classes(crowd)
+      clustered.each do |genome, array|
+        if array.length > 1
+          result.concat array
+        end
+      end
+      return result
+    end
+  end
+end

data/lib/search/stations/station.rb

@@ -0,0 +1,147 @@
+module Nudge
+  class Station
+    require 'set'
+    
+    def self.stations
+      @stations ||= self.cleanup
+    end
+    
+    def self.cleanup
+      @stations = Hash[:DEAD,DeadStation.new]
+    end
+    
+    
+    attr_reader :name
+    attr_accessor :downstream, :population, :capacity
+    attr_accessor :settings
+    attr_accessor :database
+    attr_accessor :cull_check, :generate_rule, :promotion_rule, :cull_rule
+    
+    
+    def initialize(name, params = {})
+      if !Station.stations.include? name
+        @name = name
+      else
+        raise ArgumentError, "Station names must be unique"
+      end
+      
+      @capacity = params[:capacity] || 100
+      @settings = InterpreterSettings.new(params)
+      @population = []
+      @downstream = Set.new
+      
+      @generate_rule = params[:generate_rule] || Proc.new { |crowd| RandomGuessOperator.new.generate}
+      @promotion_rule = params[:promotion_rule] || Proc.new { |indiv| false }
+      @cull_check = params[:cull_check] || Proc.new {@population.length > @capacity}
+      if params[:database]
+        @database = "#{params[:database]}/#{@name}"
+      else 
+        @database = "http://localhost:5984/#{@name}"
+      end
+      
+      Station.stations[@name] = self
+    end
+    
+    
+    def flows_into(otherPlace)
+      @downstream.add(otherPlace.name)
+    end
+    
+    
+    def breeding_pool
+      result = []
+      result += @population
+      @downstream.each do |place|
+        result += Station.stations[place].population
+      end
+      return result
+    end
+    
+    
+    def add_individual(newDude)
+      newDude.station = self
+      @population << newDude
+    end
+    
+    
+    def transfer(popIndex, newStationName)
+      if popIndex < 0 || popIndex > @population.length
+        raise ArgumentError, "self#transfer called with index #{popIndex}"
+      end
+      if !Station.stations.include?(newStationName)
+        raise ArgumentError, "self#transfer called with nonexistent station \"#{newStationName}\""
+      end
+      
+      movedDude = @population[popIndex]
+      Station.stations[newStationName].population << movedDude
+      @population.delete_at(popIndex)
+      movedDude.station = Station.stations[newStationName]
+    end
+    
+    
+    def promote?(myDude)
+      return @promotion_rule.call(myDude)
+    end
+    
+    
+    def promote(popIndex, newLoc = nil)
+      if newLoc
+        raise(ArgumentError,
+          "\"#{@name}\" is not connected to \"#{newLoc}\"") if !@downstream.include?(newLoc)
+      else
+        newLoc = @downstream.to_a.sample || self.name
+      end
+      self.transfer(popIndex,newLoc)
+    end
+    
+    
+    def review_and_promote
+      up_for_promotion = @population.find_all {|dude| self.promote?(dude) }
+      up_for_promotion.each {|dude| self.promote(@population.find_index(dude)) }
+    end
+    
+    
+    def cull?
+      return cull_check.call
+    end
+    
+    
+    def review_and_cull
+    end
+    
+    
+    def cull_all
+      @population.length.times do
+        self.transfer(0, :DEAD)
+      end
+    end
+    
+    
+    def generate
+      prospects = self.breeding_pool
+      my_babies = self.generate_rule.call( prospects )
+      @population += my_babies
+    end
+    
+    
+    def core_cycle
+      self.generate
+      self.review_and_promote
+      self.review_and_cull
+    end
+  end
+  
+  
+  
+  
+  class DeadStation < Station
+    def initialize()
+      @name = :DEAD
+      @capacity = nil
+      @population = []
+    end
+    
+    def core_cycle
+    end
+  end
+end

data/push_language_coverage.md

@@ -0,0 +1,177 @@
+INTEGER instructions
+
+INTEGER.%:           IntModuloInstruction
+INTEGER.*:           IntMultiplyInstruction
+INTEGER.+:           IntAddInstruction
+INTEGER.-:           IntSubtractInstruction
+INTEGER./:           IntDivideInstruction
+INTEGER.<:           IntLessThanQInstruction
+INTEGER.=:           IntEqualQInstruction
+INTEGER.>:           IntGreaterThanQInstruction
+INTEGER.DEFINE:      IntDefineInstruction
+INTEGER.DUP:         IntDuplicateInstruction
+INTEGER.FLUSH:       IntFlushInstruction
+INTEGER.FROMBOOLEAN: IntFromBoolInstruction
+INTEGER.FROMFLOAT:   IntFromFloatInstruction
+INTEGER.MAX:         IntMaxInstruction
+INTEGER.MIN:         IntMinInstruction
+INTEGER.POP:         IntPopInstruction
+INTEGER.RAND:        IntRandomInstruction
+INTEGER.ROT:         IntRotateInstruction
+INTEGER.SHOVE:       IntShoveInstruction
+INTEGER.STACKDEPTH:  IntDepthInstruction
+INTEGER.SWAP:        IntSwapInstruction
+INTEGER.YANK:        IntYankInstruction
+INTEGER.YANKDUP:     IntYankdupInstruction
+
+                     IntAbsInstruction
+                     IntIfInstruction
+                     IntNegativeInstruction
+
+FLOAT instructions
+
+FLOAT.%:             FloatModuloInstruction
+FLOAT.*:             FloatMultiplyInstruction
+FLOAT.+:             FloatAddInstruction
+FLOAT.-:             FloatSubtractInstruction
+FLOAT./:             FloatDivideInstruction
+FLOAT.<:             FloatLessThanQInstruction
+FLOAT.=:             FloatEqualQInstruction
+FLOAT.>:             FloatGreaterThanQInstruction
+FLOAT.COS:           FloatCosineInstruction
+FLOAT.DEFINE:        FloatDefineInstruction
+FLOAT.DUP:           FloatDuplicateInstruction
+FLOAT.FLUSH:         FloatFlushInstruction
+FLOAT.FROMBOOLEAN:   FloatFromBoolInstruction
+FLOAT.FROMINTEGER:   FloatFromIntInstruction
+FLOAT.MAX:           FloatMaxInstruction
+FLOAT.MIN:           FloatMinInstruction
+FLOAT.POP:           FloatPopInstruction
+FLOAT.RAND:          FloatRandomInstruction
+FLOAT.ROT:           FloatRotateInstruction
+FLOAT.SHOVE:         FloatShoveInstruction
+FLOAT.SIN:           FloatSineInstruction
+FLOAT.STACKDEPTH:    FloatDepthInstruction
+FLOAT.SWAP:          FloatSwapInstruction
+FLOAT.TAN:           FloatTangentInstruction
+FLOAT.YANK:          FloatYankInstruction
+FLOAT.YANKDUP:       FloatYankdupInstruction
+                     
+                     FloatAbsInstruction
+                     FloatIfInstruction
+                     FloatNegativeInstruction
+                     FloatPowerInstruction
+                     FloatSqrtInstruction
+
+BOOLEAN instructions
+
+BOOLEAN.=:           BoolEqualQInstruction
+BOOLEAN.AND:         BoolAndInstruction
+BOOLEAN.DEFINE:      BoolDefineInstruction
+BOOLEAN.DUP:         BoolDuplicateInstruction
+BOOLEAN.FLUSH:       BoolFlushInstruction
+BOOLEAN.FROMFLOAT:   BoolFromFloatInstruction
+BOOLEAN.FROMINTEGER: BoolFromIntInstruction
+BOOLEAN.NOT:         BoolNotInstruction
+BOOLEAN.OR:          BoolOrInstruction
+BOOLEAN.POP:         BoolPopInstruction
+BOOLEAN.RAND:        BoolRandomInstruction
+BOOLEAN.ROT:         BoolRotateInstruction
+BOOLEAN.SHOVE:       BoolShoveInstruction
+BOOLEAN.STACKDEPTH:  BoolDepthInstruction
+BOOLEAN.SWAP:        BoolSwapInstruction
+BOOLEAN.YANK:        BoolYankInstruction
+BOOLEAN.YANKDUP:     BoolYankdupInstruction
+
+                     BoolXorInstruction
+
+
+
+NAME instructions
+
+NAME.=:              NameEqualQInstruction
+NAME.DUP:            NameDupInstruction
+NAME.FLUSH:          NameFlushInstruction
+NAME.POP:            NamePopInstruction
+NAME.QUOTE:          NameDisableLookupInstruction
+NAME.RAND:           NameNextInstruction
+NAME.RANDBOUNDNAME:  NameRandomBoundInstruction
+NAME.ROT:            NameRotInstruction
+NAME.SHOVE:          NameShoveInstruction
+NAME.STACKDEPTH:     NameDepthInstruction
+NAME.SWAP:           NameSwapInstruction
+NAME.YANK:           NameYankInstruction
+NAME.YANKDUP:        NameYankdupInstruction
+
+
+
+EXEC instructions
+
+EXEC.=:              ExecEqualQInstruction
+EXEC.DEFINE:         ExecDefineInstruction
+EXEC.DO*COUNT:       ExecDoCountInstruction
+EXEC.DO*RANGE:       ExecDoRangeInstruction
+EXEC.DO*TIMES:       ExecDoTimesInstruction
+EXEC.DUP:            ExecDuplicateInstruction
+EXEC.FLUSH:          ExecFlushInstruction
+EXEC.IF:             ExecIfInstruction
+EXEC.K:              ExecKInstruction
+EXEC.POP:            ExecPopInstruction
+EXEC.ROT:            ExecRotateInstruction
+EXEC.S:              ExecSInstruction
+EXEC.SHOVE:          ExecShoveInstruction
+EXEC.STACKDEPTH:     ExecDepthInstruction
+EXEC.SWAP:           ExecSwapInstruction
+EXEC.Y:              ExecYInstruction
+EXEC.YANK:           ExecYankInstruction
+EXEC.YANKDUP:        ExecYankdupInstruction
+
+
+
+CODE instructions
+
+CODE.=: 
+CODE.APPEND: 
+CODE.ATOM: 
+CODE.CAR: 
+CODE.CDR: 
+CODE.CONS: 
+CODE.CONTAINER: 
+CODE.CONTAINS: 
+CODE.DEFINE: 
+CODE.DEFINITION: 
+CODE.DISCREPANCY: 
+CODE.DO: 
+CODE.DO*: 
+CODE.DO*COUNT:
+CODE.DO*RANGE: 
+CODE.DO*TIMES: 
+CODE.DUP:            CodeDuplicateInstruction
+CODE.EXTRACT: 
+CODE.FLUSH:          CodeFlushInstruction
+CODE.FROMBOOLEAN: 
+CODE.FROMFLOAT: 
+CODE.FROMINTEGER: 
+CODE.FROMNAME: 
+CODE.IF: 
+CODE.INSERT: 
+CODE.INSTRUCTIONS: 
+CODE.LENGTH: 
+CODE.LIST: 
+CODE.MEMBER: 
+CODE.NOOP:           CodeNoopInstruction
+CODE.NTH: 
+CODE.NTHCDR: 
+CODE.NULL: 
+CODE.POP:            CodePopInstruction
+CODE.POSITION: 
+CODE.QUOTE: 
+CODE.RAND: 
+CODE.ROT:            CodeRotateInstruction
+CODE.SHOVE:          CodeShoveInstruction
+CODE.SIZE: 
+CODE.STACKDEPTH:     CodeDepthInstruction
+CODE.SUBST: 
+CODE.SWAP:           CodeSwapInstruction
+CODE.YANK:           CodeYankInstruction
+CODE.YANKDUP:        CodeYankdupInstruction

data/readme.md

@@ -0,0 +1,19 @@
+# Pragmatic Genetic Programming
+
+The first release of the Pragmatic GP package will include a Ruby implementation of a [Push 3.0 language interpreter](http://hampshire.edu/lspector/push3-description.html "Push 3"), a framework for setting up and managing straightforward genetic programming projects using an [ALPS](http://idesign.ucsc.edu/projects/alps.html "ALPS algorithms")-based algorithm, and a simple architecture for monitoring and exploring the results of GP runs as they arise.
+
+This is a complete rewrite of an earlier project written in Python, and is really just a huge down-to-the-roots refactoring that relies on a lot of Ruby's more convenient metaprogramming features.
+
+We're building this from the bottom up, so it doesn't "work" in the sense you might expect. At the moment, only the specs pass. There isn't any centralized run behavior in place yet, though that will be coming soon.
+
+## Requirements
+
+For the time being requirements need to be installed by hand.
+
+First, the codebase increasingly relies on features of ruby 1.9.1. If you'd like to work with it, I'd recommend using [rvm](http://rvm.beginrescueend.com/) to set it up to work alongside the other version(s) of the Ruby interpreter your system may depend on.
+
+You'll need to download and install [couchDB](http://couchdb.apache.org/), and have it running before launching a full-fledged Nudge Experiment.
+
+To run and verify the codebase, you'll need to have recent versions of the following gems: [haml](http://haml-lang.com/), [sinatra](http://www.sinatrarb.com/), [treetop](http://treetop.rubyforge.org/), [activesupport](http://as.rubyonrails.org/), and [couchrest](http://github.com/jchris/couchrest); [rspec](http://rspec.info/), [cucumber](http://cukes.info/) and [fakeweb](http://fakeweb.rubyforge.org/) to be able to run the specs and confirm the codebase works on your system.
+
+If as we are you're developing with TextMate, you'll need to make sure your 'PATH' variable in the application is set correctly by adding the path to your *active* ruby binary and gems to the front.

data/spec/data/couchdb_spec.rb

@@ -0,0 +1,2 @@
+require File.join(File.dirname(__FILE__), "/../spec_helper")
+include Nudge

data/spec/fixtures/just_block.example

@@ -0,0 +1 @@
+block {}

data/spec/fixtures/just_block_with_newline.example

@@ -0,0 +1 @@
+<%= fixture(:just_block)%>

data/spec/fixtures/long_arithmetic.example

@@ -0,0 +1,7 @@
+block {
+  literal int(8)
+  literal int(9)
+  do int_multiply
+  block {
+    sample int(-2)
+    do int_divide}}

data/spec/fixtures/one_line_instr.example

@@ -0,0 +1 @@
+do foo_bar

data/spec/fixtures/untidy1.example

@@ -0,0 +1,20 @@
+block {
+do fee
+block {
+    block
+{
+
+do fie
+      block {
+      
+      }}
+block {
+      do foe
+do fum
+} literal float ( -8812.1
+)}
+ref u
+block {
+
+}
+}

data/spec/fixtures/untidy1fixed.example

@@ -0,0 +1,12 @@
+block {
+  do fee
+  block {
+    block {
+      do fie
+      block {}}
+    block {
+      do foe
+      do fum}
+    literal float (-8812.1)}
+  ref u
+  block {}}