answer-factory 0.0.9 → 0.0.10

data/spec/operators/uniformBackboneCrossover_spec.rb

@@ -14,23 +14,23 @@ describe "UniformBackboneCrossoverOperator" do
   end
   
   it "should produce a Batch of Answers when it receives #generate" do
-    @newDudes = @myXover.generate(@myGuesser.generate(2))
+    @newDudes = @myXover.generate(@myGuesser.generate(Batch.new,how_many:2))
     @newDudes.should be_a_kind_of(Batch)
     @newDudes.each {|dude| dude.should be_a_kind_of(Answer)}
   end
   
   it "should produce the same number of Answers it gets as a default" do
-    @newDudes = @myXover.generate(@myGuesser.generate(6))
+    @newDudes = @myXover.generate(@myGuesser.generate(Batch.new,how_many:6))
     @newDudes.length.should == 6
   end
   
   it "should have an optional parameter that specifies the number of offspring to produce" do
-    @newDudes = @myXover.generate(@myGuesser.generate(2),5)
+    @newDudes = @myXover.generate(@myGuesser.generate(Batch.new,how_many:2),5)
     @newDudes.length.should == 5
   end
   
   it "should only include backbone points from one of the parents in the offsprings' genomes" do
-    rents = @myGuesser.generate(2)
+    rents = @myGuesser.generate(Batch.new,how_many:2)
     @newDudes = @myXover.generate(rents,1)
     @newDudes.length.should == 1
     allParentalPoints = rents[0].program[1].contents + rents[1].program[1].contents
@@ -38,21 +38,21 @@ describe "UniformBackboneCrossoverOperator" do
   end
   
   it "should return an identical individual if given only one parent" do
-    rent = @myGuesser.generate(1)
+    rent = @myGuesser.generate(Batch.new,how_many:1)
     @newDudes = @myXover.generate(rent,3)
     @newDudes.each {|kid| kid.program.tidy.should == rent[0].program.tidy}
   end
   
   
   it "should not affect the original parents set in any way" do
-    rents = @myGuesser.generate(2)
+    rents = @myGuesser.generate(Batch.new,how_many:2)
     originalMom = rents[0].object_id
     @newDudes = @myXover.generate(rents,1)
     rents[0].object_id.should == originalMom
   end
   
   it "should return offspring with #progress values incremented from the largest parent value" do
-    rents = @myGuesser.generate(2)
+    rents = @myGuesser.generate(Batch.new,how_many:2)
     rents[0].should_receive(:progress).at_least(1).times.and_return(12)
     rents[1].should_receive(:progress).at_least(1).times.and_return(33)
     @newDudes = @myXover.generate(rents,20)

data/spec/spec_helper.rb

@@ -3,6 +3,7 @@ $: << File.join(File.dirname(__FILE__), "/../lib")
 
 require 'spec'
 require 'fakeweb'
+require 'couchrest'
 require './lib/answer-factory'
 
 include AnswerFactory

metadata

@@ -5,8 +5,8 @@ version: !ruby/object:Gem::Version
   segments: 
   - 0
   - 0
-  - 9
-  version: 0.0.9
+  - 10
+  version: 0.0.10
 platform: ruby
 authors: 
 - Bill Tozier
@@ -16,7 +16,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2010-05-02 00:00:00 -04:00
+date: 2010-05-06 00:00:00 -04:00
 default_executable: answer-factory
 dependencies: 
 - !ruby/object:Gem::Dependency 
@@ -59,9 +59,23 @@ dependencies:
   type: :runtime
   version_requirements: *id003
 - !ruby/object:Gem::Dependency 
-  name: fakeweb
+  name: configatron
   prerelease: false
   requirement: &id004 !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        segments: 
+        - 2
+        - 6
+        - 2
+        version: 2.6.2
+  type: :runtime
+  version_requirements: *id004
+- !ruby/object:Gem::Dependency 
+  name: fakeweb
+  prerelease: false
+  requirement: &id005 !ruby/object:Gem::Requirement 
     requirements: 
     - - ">="
       - !ruby/object:Gem::Version 
@@ -70,11 +84,11 @@ dependencies:
         - 33
         version: "0.33"
   type: :runtime
-  version_requirements: *id004
+  version_requirements: *id005
 - !ruby/object:Gem::Dependency 
   name: sinatra
   prerelease: false
-  requirement: &id005 !ruby/object:Gem::Requirement 
+  requirement: &id006 !ruby/object:Gem::Requirement 
     requirements: 
     - - ">="
       - !ruby/object:Gem::Version 
@@ -84,11 +98,11 @@ dependencies:
         - 4
         version: 0.9.4
   type: :runtime
-  version_requirements: *id005
+  version_requirements: *id006
 - !ruby/object:Gem::Dependency 
   name: activesupport
   prerelease: false
-  requirement: &id006 !ruby/object:Gem::Requirement 
+  requirement: &id007 !ruby/object:Gem::Requirement 
     requirements: 
     - - ">="
       - !ruby/object:Gem::Version 
@@ -98,7 +112,7 @@ dependencies:
         - 5
         version: 2.3.5
   type: :runtime
-  version_requirements: *id006
+  version_requirements: *id007
 description: The pragmaticgp gem provides a simple framework for building, running and managing genetic programming experiments which automatically discover algorithms and equations to solve user-defined problems.
 email: bill@vagueinnovation.com
 executables: 
@@ -122,9 +136,21 @@ files:
 - lib/answers/batch.rb
 - lib/factories/factory.rb
 - lib/factories/workstation.rb
-- lib/operators/basic_operators.rb
-- lib/operators/evaluators.rb
-- lib/operators/samplers_and_selectors.rb
+- lib/operators/all_duplicated_genomes_sampler.rb
+- lib/operators/any_one_sampler.rb
+- lib/operators/dominated_quantile_selector.rb
+- lib/operators/infrastructure.rb
+- lib/operators/most_dominated_subset_sampler.rb
+- lib/operators/nondominated_subset_selector.rb
+- lib/operators/point_crossover_operator.rb
+- lib/operators/point_delete_operator.rb
+- lib/operators/point_mutation_operator.rb
+- lib/operators/program_point_count_evaluator.rb
+- lib/operators/random_guess_operator.rb
+- lib/operators/resample_and_clone_operator.rb
+- lib/operators/resample_values_operator.rb
+- lib/operators/test_case_evaluator.rb
+- lib/operators/uniform_backbone_crossover_operator.rb
 - pkg/nudgegp-0.0.1.gem
 - readme.md
 - spec/answer_spec.rb

data/lib/operators/basic_operators.rb

@@ -1,240 +0,0 @@
-#encoding: utf-8
-module AnswerFactory
-  
-  # Abstract class that from which specific SearchOperator subclasses inherit initialization
-  
-  class SearchOperator
-    attr_accessor :incoming_options
-    
-     def initialize(options={})
-       @incoming_options = options
-     end
-  end
-  
-  
-  
-  
-  class RandomGuessOperator < SearchOperator
-    
-    # returns an Array of random Answers
-    #
-    # the first (optional) parameter specifies how many to make, and defaults to 1
-    # the second (also optional) parameter is a hash that
-    # can 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 Answer, 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 Answer whose IntType samples (if any) will be between [0,100]
-    
-    def generate(howMany = 1, overridden_options ={})
-      result = Batch.new
-      howMany.times do
-        newGenome = CodeType.any_value(@incoming_options.merge(overridden_options))
-        newDude = Answer.new(newGenome, progress:0)
-        result << newDude
-      end
-      result
-    end
-  end
-  
-  
-  
-  
-  class ResampleAndCloneOperator < SearchOperator
-    
-    # returns an Array of clones of Answers randomly selected from the crowd passed in
-    # 
-    # the first (required) parameter is an Array of Answers
-    # the second (optional) parameter is how many samples to take, and defaults to 1
-    #
-    # For example, if
-    # <tt>@currentPopulation = [a list of 300 Answers]</tt> and
-    # <tt>myRandomSampler = ResampleAndCloneOperator.new(@currentPopulation)</tt>
-    # [<tt>myRandomSampler.generate()</tt>]
-    #   produces a list of 1 Answer, which is a clone of somebody from <tt>@currentPopulation</tt>
-    # [<tt>myRandomGuesser.generate(11)</tt>]
-    #   returns a list of 11 Answers cloned from <tt>@currentPopulation</tt>,
-    #   possibly including repeats
-    
-    def generate(crowd, howMany = 1)
-      result = Batch.new
-      howMany.times do
-        donor = crowd.sample
-        clone = Answer.new(donor.blueprint, progress:donor.progress + 1)
-        result << clone
-      end
-      return result
-    end
-  end
-  
-  
-  
-  
-  class ResampleValuesOperator < SearchOperator
-    
-    def generate(crowd, howManyCopies = 1, overridden_options = {})
-      crowd.each {|dude| raise(ArgumentError) if !dude.kind_of?(Answer) }
-      
-      result = Batch.new
-      regenerating_options = @incoming_options.merge(overridden_options)
-      crowd.each do |dude|
-        howManyCopies.times do
-          wildtype_program = dude.program
-          starting_footnotes = wildtype_program.footnote_section.split( /^(?=«)/ )
-          breaker = /^«([a-zA-Z][a-zA-Z0-9_]*)»\s*(.*)\s*/m
-          type_value_pairs = starting_footnotes.collect {|fn| fn.match(breaker)[1..2]}
-          
-          mutant_blueprint = wildtype_program.code_section
-          
-          type_value_pairs.each do |pair|
-            
-            begin
-              type_name = pair[0]
-              type_class = "#{type_name}_type".camelize.constantize
-              reduced_size = regenerating_options[:target_size_in_points] || rand(dude.points/2)
-              reduced_option = {target_size_in_points:reduced_size}
-              resampled_value = type_class.any_value(regenerating_options.merge(reduced_option)).to_s
-            rescue NameError
-              resampled_value = pair[1]
-            end            
-            mutant_blueprint << "\n«#{pair[0].strip}» #{resampled_value.strip}"
-          end
-          mutant = Answer.new(mutant_blueprint, progress:dude.progress + 1)
-          result << mutant
-        end
-      end
-      return result
-    end
-  end
-  
-  
-  
-  
-  class UniformBackboneCrossoverOperator < SearchOperator
-    
-    # Returns a Batch of new Answers whose programs are made by stitching together
-    # the programs of pairs of 'parents'. The incoming Batch is divided into pairs based on
-    # adjacency (modulo the Batch.length), one pair for each 'offspring' to be made. To make
-    # an offspring, the number of backbone program points is determined in each parent; 'backbone'
-    # refers to the number of branches directly within the root of the program, not the entire tree.
-    #
-    # To construct an offspring's program, program points are copied from the first parent with
-    # probability p, or the second parent with probability (1-p), for each point in the first
-    # parent's backbone. So if there are 13 and 6 points, respectively, the first six points are
-    # selected randomly, but the last 7 are copied from the first parent. If there are 8 and 11
-    # respectively, then the last 3 will be ignored from the second parent in any case.
-    #   
-    #   the first (required) parameter is an Array of Answers
-    #   the second (optional) parameter is how many crossovers to make,
-    #     which defaults to the number of Answers in the incoming Batch
-    
-    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 ]
-        mom_backbone_length = mom.program[1].contents.length
-        dad_backbone_length = dad.program[1].contents.length
-        
-        baby_blueprint_parts = ["",""]
-        (0..mom_backbone_length-1).each do |backbone_point|
-          if rand() < prob
-            next_chunks = mom.program[1].contents[backbone_point].blueprint_parts || ["",""]
-          else
-            if backbone_point < dad_backbone_length
-              next_chunks = (dad.program[1].contents[backbone_point].blueprint_parts || ["", ""])
-            else
-              next_chunks = ["",""]
-            end
-          end
-          baby_blueprint_parts[0] << " #{next_chunks[0]}"
-          baby_blueprint_parts[1] << " \n#{next_chunks[1]}"
-        end
-        mom.program.unused_footnotes.each {|fn| baby_blueprint_parts[1] += "\n#{fn}"}
-        
-        baby_blueprint = "block {#{baby_blueprint_parts[0]}} #{baby_blueprint_parts[1]}"
-        baby = Answer.new(baby_blueprint, 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?(Answer) }
-      
-      result = Batch.new
-      production = crowd.length*howManyBabies
-      production.times do
-        mom = crowd.sample
-        dad = crowd.sample
-        mom_receives = rand(mom.points) + 1
-        dad_donates = rand(dad.points) + 1
-        
-        baby_blueprint = mom.replace_point_or_clone(mom_receives,dad.program[dad_donates])
-        baby = Answer.new(baby_blueprint,
-          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?(Answer) }
-      
-      result = Batch.new
-      crowd.each do |dude|
-        howManyCopies.times do
-          where = rand(dude.points)+1
-          variant = dude.delete_point_or_clone(where)
-          baby = Answer.new(variant, progress:dude.progress + 1)
-          result << baby
-        end
-      end
-      return result
-    end
-  end
-  
-  
-  
-  
-  class PointMutationOperator < SearchOperator
-    
-    def generate(crowd, howManyCopies = 1, overridden_options ={})
-      raise(ArgumentError) if !crowd.kind_of?(Array)
-      raise(ArgumentError) if crowd.empty?
-      crowd.each {|dude| raise(ArgumentError) if !dude.kind_of?(Answer) }
-      
-      result = Batch.new
-      crowd.each do |dude|
-        howManyCopies.times do
-          where = rand(dude.points)+1
-          newCode = CodeType.any_value(@incoming_options.merge(overridden_options))
-          variant = dude.replace_point_or_clone(where,newCode)
-          baby = Answer.new(variant, progress:dude.progress + 1)
-          result << baby 
-        end
-      end
-      return result
-    end
-  end
-end

data/lib/operators/samplers_and_selectors.rb

@@ -1,131 +0,0 @@
-module AnswerFactory
-  
-  class Sampler < SearchOperator
-    def initialize (params = {})
-      super
-    end
-    
-    def all_known_criteria(crowd)
-      union = []
-      crowd.each do |dude|
-        union |= dude.known_criteria
-      end
-      return union
-    end
-    
-    
-    def all_shared_scores(crowd)
-      intersection = self.all_known_criteria(crowd)
-      crowd.each do |dude|
-        intersection = intersection & dude.known_criteria
-      end
-      return intersection
-    end
-    
-    
-    def domination_classes(crowd, template = all_shared_scores(crowd))
-      result = Hash.new()
-      
-      crowd.each_index do |i|
-        dominated_by = 0
-        
-        crowd.each_index do |j|
-          dominated_by += 1 if crowd[i].dominated_by?(crowd[j], template)
-        end
-        
-        result[dominated_by] ||= []
-        result[dominated_by].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 |answer|
-        dominated = false
-        crowd.each do |other_answer|
-          dominated ||= answer.dominated_by?(other_answer, template)
-        end
-        result << answer unless dominated
-      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).ceil
-      
-      result = Batch.new
-      partial_ordering[0...how_many].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 |blueprint, array|
-        if array.length > 1
-          result.concat array
-        end
-      end
-      return result
-    end
-  end
-end