answer-factory 0.0.1

data/spec/operators/duplicate_genomes_spec.rb

@@ -0,0 +1,35 @@
+require File.join(File.dirname(__FILE__), "./../spec_helper")
+
+
+describe AllDuplicatedGenomesSampler do
+  before(:each) do
+    @dg = AllDuplicatedGenomesSampler.new
+  end
+  
+  
+  describe "#generate" do
+    before(:each) do
+      @dudes = Batch[Answer.new("block {}"), Answer.new("block {}"), Answer.new("do int_add")]
+    end
+    
+    it "should take a Batch as a first parameter" do
+      lambda{@dg.generate()}.should raise_error(ArgumentError)
+      lambda{@dg.generate(@dudes)}.should_not raise_error(ArgumentError)
+    end
+
+    it "should return a Batch" do
+      @dg.generate(@dudes).should be_a_kind_of(Batch)
+    end
+    
+    it "should return a Batch containing references to individuals in the original Batch" do
+      repeats = @dg.generate(@dudes)
+      repeats.length.should == 2
+      repeats.each {|dude| @dudes.should include(dude)}
+    end
+    
+    it "should return an empty Batch if there are no duplicates" do
+      @dudes.delete_at(0)
+      @dg.generate(@dudes).should be_empty
+    end
+  end
+end

data/spec/operators/evaluators/program_point_evaluator_spec.rb

@@ -0,0 +1,43 @@
+require File.join(File.dirname(__FILE__), "./../../spec_helper")
+
+
+describe ProgramPointEvaluator do
+  
+  describe "initialization" do
+    it "should have an objective name set upon initialization" do
+      lambda{ProgramPointEvaluator.new}.should raise_error(ArgumentError)
+    end
+  end
+  
+  describe "#evaluate" do
+    before(:each) do
+      @ppe = ProgramPointEvaluator.new(:name => :point_count)
+      @dudes = Batch[
+        Answer.new("block {}"),
+        Answer.new("block { block {}}"),
+        Answer.new("block { block { block {}}}")
+      ]
+    end
+    
+    it "should take a Batch of individuals as an argument" do
+      lambda{@ppe.evaluate(Answer.new("block {}"))}.should raise_error(ArgumentError)
+      lambda{@ppe.evaluate(Batch[Answer.new("block {}")])}.should_not raise_error(ArgumentError)
+    end
+    
+    it "should raise an exception if it can't evaluate an Answer" do
+      lambda{@ppe.evaluate(Batch[Answer.new("blah_de_blah")])}.should raise_error(ArgumentError)
+    end
+    
+    it "should write the number of program points into each individual" do
+      @dudes.each {|dude| dude.scores[:point_count].should == nil}
+      @ppe.evaluate(@dudes)
+      @dudes.collect {|dude| dude.scores[:point_count]}.should == [1,2,3]
+    end
+    
+    it "should return the same Batch it got, with updated values" do
+      origIDs = @dudes.collect {|dude| dude.object_id}
+      @ppe.evaluate(@dudes)
+      @dudes.each {|dude| origIDs.should include(dude.object_id)}
+    end
+  end
+end

data/spec/operators/evaluators/test_case_evaluator_spec.rb

@@ -0,0 +1,129 @@
+#encoding: utf-8
+require File.join(File.dirname(__FILE__), "./../../spec_helper")
+
+
+describe TestCase do
+  describe "bindings" do
+    it "should have a Hash of independent variable names and assigned values" do
+      TestCase.new.should respond_to(:bindings)
+    end
+  end
+  
+  describe "expectations" do
+    it "should have a Hash of dependent variable names and expected values" do
+      TestCase.new.should respond_to(:expectations)
+    end
+  end
+  
+  describe "gauges" do
+    it "should have a Hash of Proc objects that measure the observed values" do
+      TestCase.new.should respond_to(:gauges)
+    end
+    
+    it "should have one gauge for every expectation" do
+      lambda{TestCase.new(
+        :expectations => {"y1"=>ValuePoint.new("int", 31)},
+        :gauges => {"h"=>Proc.new {} } )}.should raise_error
+      lambda{TestCase.new(
+        :expectations => {"y1"=>ValuePoint.new("int", 31)},
+        :gauges => {"y1"=>Proc.new {} } )}.should_not raise_error
+    end
+  end
+end
+
+
+
+
+
+describe TestCaseEvaluator do
+  describe "initialize" do
+    it "should have a name" do
+      lambda{TestCaseEvaluator.new()}.should raise_error(ArgumentError)
+      lambda{TestCaseEvaluator.new(name:"boolean_multiplexer_SSE")}.should_not raise_error
+    end
+    
+    it "should have all the info it needs to set up an Interpreter"
+  end
+  
+  describe "evaluate" do
+    before(:each) do
+      @tce = TestCaseEvaluator.new(:name => :error)
+      @dudes = Batch[
+        Answer.new("value «int»\n«int» 12"),
+        Answer.new("value «int»\n«int» -9912"),
+        Answer.new("value «bool»\n«bool» false"),
+        Answer.new("block { value «int» value «int»}\n«int» 99\n«int» 12")
+      ]
+      @cases = [
+        TestCase.new(:bindings => {"x" => ValuePoint.new("int",77)},
+          :expectations => {"y" => 12},
+          :gauges => {"y" => Proc.new {|interp| interp.stacks[:int].peek}}
+        ),
+        TestCase.new(:bindings => {"x" => ValuePoint.new("int",78)},
+          :expectations => {"y" => 13},
+          :gauges => {"y" => Proc.new {|interp| interp.stacks[:int].peek}}
+        )
+      ]
+    end
+    
+    it "should raise an exception if the batch argument isn't a Batch" do
+      lambda{@tce.evaluate()}.should raise_error(ArgumentError)
+      lambda{@tce.evaluate(@dudes)}.should_not raise_error(ArgumentError)
+    end
+    
+    it "should assign a numeric score to all the Answers in the Batch" do
+      @dudes.each {|dude| dude.scores[:error].should == nil}
+      @tce.evaluate(@dudes, @cases)
+      @dudes.each {|dude| dude.scores[:error].kind_of?(Numeric).should == true}
+    end
+    
+    it "should create an Interpreter for each run" do
+      myI = Interpreter.new
+      Interpreter.should_receive(:new).exactly(8).times.and_return(myI)
+      @tce.evaluate(@dudes, @cases)
+    end
+    
+    it "should be reset each time before running them" do
+      myI = Interpreter.new
+      Interpreter.stub!(:new).and_return(myI)
+      myI.should_receive(:reset).exactly(8).times
+      @tce.evaluate(@dudes, @cases)
+    end
+    
+    it "should set up bindings before running them" do
+      myI = Interpreter.new
+      Interpreter.stub!(:new).and_return(myI)
+      myI.should_receive(:bind_variable).exactly(8).times
+      @tce.evaluate(@dudes, @cases)
+    end
+    
+    it "should run each TestCase for each individual in the Batch" do
+      myI = Interpreter.new
+      Interpreter.stub!(:new).and_return(myI)
+      myI.should_receive(:run).exactly(8).times
+      @tce.evaluate(@dudes, @cases)
+    end
+    
+    it "after running a TestCase using an Answer, all the gauges should be called" do
+      myI = Interpreter.new
+      Interpreter.stub!(:new).and_return(myI)
+      myI.should_receive(:run).exactly(8).times
+      @tce.evaluate(@dudes, @cases)
+      
+      myI.should_receive(:run).exactly(4).times
+      @tce.evaluate(@dudes, [TestCase.new(:gauges => {"a" => Proc.new {|interp|}})])
+    end
+    
+    it "should synthesize the gauge readings into a single numerical score"
+    
+    it "should loop over the test cases to collect the error" do
+      @dudes.each {|dude| dude.scores[:error].should == nil}
+      
+      @tce.evaluate(@dudes, @cases)
+      equal12or13error = @dudes.collect {|dude| dude.scores[:error]}
+      expectedScores = [1, 19849, 200000, 1]
+      (0..3).each {|i| equal12or13error[i].should be_close(expectedScores[i].to_f / 2, 0.0001)}
+    end
+    
+  end
+end

data/spec/operators/infrastructure_spec.rb

@@ -0,0 +1,45 @@
+require File.join(File.dirname(__FILE__), "./../spec_helper")
+
+
+describe "domination_classes" do
+  before(:each) do
+    @dq = Sampler.new
+    
+    @dudes = Batch[Answer.new("block {}"), Answer.new("do int_add")]
+    @dudes[0].scores["first"] = 120
+    @dudes[1].scores["first"] = 2
+    @dudes[0].scores["second"] = 2
+    @dudes[1].scores["second"] = 120
+    @dudes[0].scores["third"] = 20
+    @dudes[1].scores["third"] = 1200
+  end
+  
+  it "should take a Batch as an argument" do
+    lambda{@dq.domination_classes()}.should raise_error(ArgumentError)
+    lambda{@dq.domination_classes(@dudes)}.should_not raise_error(ArgumentError)
+    
+  end
+  
+  it "can take a template of objective names to use" do
+    lambda{@dq.domination_classes(@dudes, ["first"])}.should_not raise_error(ArgumentError)
+  end
+  
+  it "should return a Hash" do
+    @dq.domination_classes(@dudes, ["first"]).should be_a_kind_of(Hash)
+  end
+  
+  it "should use the count of dominating Answers as the key" do
+    @dq.domination_classes(@dudes, ["second"]).keys.should == [0,1]
+    @dq.domination_classes(@dudes).keys.should == [0]
+    
+  end
+  
+  it "should have an Array of the Answers in that class as the value" do
+    @dq.domination_classes(@dudes, ["first"])[0].length.should == 1
+    @dq.domination_classes(@dudes, ["first"])[0][0].should == @dudes[1]
+    @dq.domination_classes(@dudes, ["second"])[0].length.should == 1
+    @dq.domination_classes(@dudes, ["second"])[0][0].should == @dudes[0]
+    @dq.domination_classes(@dudes, ["second", "third"])[0].length.should == 1
+    @dq.domination_classes(@dudes, ["second", "third"])[0][0].should == @dudes[0]
+  end
+end

data/spec/operators/most_dominated_subset_spec.rb

@@ -0,0 +1,47 @@
+require File.join(File.dirname(__FILE__), "./../spec_helper")
+
+
+describe MostDominatedSubsetSampler do
+  before(:each) do
+    @md = MostDominatedSubsetSampler.new
+  end
+    
+  
+  describe "#generate" do
+    before(:each) do
+      @dudes = Batch[Answer.new("block {}"), Answer.new("block {}"), Answer.new("block {}")]
+      @dudes[0].scores = Hash[:first, 2,   :second, 20,  :third, 200]
+      @dudes[1].scores = Hash[:first, 20,  :second, 200, :third, 2]
+      @dudes[2].scores = Hash[:first, 200, :second, 2,   :third, 20]
+    end
+    
+    it "should take a Batch as a first parameter" do
+      lambda{@md.generate()}.should raise_error(ArgumentError)
+      lambda{@md.generate(@dudes)}.should_not raise_error(ArgumentError)
+    end
+
+    it "should return a Batch" do
+      @md.generate(@dudes).should be_a_kind_of(Batch)
+    end
+    
+    it "should return a Batch containing references to individuals in the original Batch" do
+      half = @md.generate(@dudes)
+      half.length.should be > 0
+      half.each {|dude| @dudes.should include(dude)}
+    end
+    
+    it "should always return at least one, even when everybody is nondominated" do
+      some = @md.generate(@dudes)
+      some.length.should == 3
+      some.each {|dude| @dudes.should include(dude)}
+    end
+    
+    
+    it "should take a template of objectives to use in sorting" do
+      @md.generate(@dudes,[:first]).should include(@dudes[2])
+      @md.generate(@dudes,[:second]).should include(@dudes[1])
+      @md.generate(@dudes,[:second, :third]).should include(@dudes[0])
+    end
+  end
+  
+end

data/spec/operators/nondominated_subset_spec.rb

@@ -0,0 +1,103 @@
+require File.join(File.dirname(__FILE__), "./../spec_helper")
+
+
+describe "nondominated_subset operator" do
+  before(:each) do
+    @myNondominatedScreener = NondominatedSubsetSelector.new
+    @params = {points:3, instruction_names:[:int_add, :int_multiply], type_names:["int"]}
+    @myGuesser = RandomGuessOperator.new(@params)
+    @twoGuys = @myGuesser.generate(2)
+  end
+  
+  it "should be a kind of SearchOperator" do
+    @myNondominatedScreener.should be_a_kind_of(SearchOperator)
+  end
+  
+  it "the #all_known_criteria method should return an Array with the union of all scores keys in the crowd" do
+    @twoGuys[0].scores = {x2:612, y2:77, x3:712}
+    @twoGuys[1].scores = {y1:2, x1:3, x2:4}
+    @myNondominatedScreener.all_known_criteria(@twoGuys).sort.should == [:x1,:x2, :x3, :y1, :y2].sort
+  end
+  
+  it "the #all_shared_scores method should return an Array of the keys of the #scores hashes in the crowd" do
+    twoGuys = @myGuesser.generate(2)
+    twoGuys[0].scores = {x2:612, x1:77, x3:712}
+    twoGuys[1].scores = {x2:2,   x1:3,  x3:4}
+    @myNondominatedScreener.all_shared_scores(twoGuys).sort.should == [:x1,:x2, :x3].sort
+    
+    twoGuys[0].scores = {x3:712, :something_else => 88}
+    twoGuys[1].scores = {x2:2,   :x1 => 3, :x3 => 4}
+    @myNondominatedScreener.all_shared_scores(twoGuys).sort.should == [:x3].sort
+  end
+  
+  it "should produce a Batch of Answer objects when it receives #generate; at least one" do
+    twoGuys = @myGuesser.generate(2)
+    twoGuys[0].scores = {:x2 => 612, :x1 => 77, :x3 => 712}
+    twoGuys[1].scores = {:x2 => 2, :x1 => 3, :x3 => 4}
+    @myNondominatedScreener.generate(twoGuys).should be_a_kind_of(Batch)
+    @myNondominatedScreener.generate(twoGuys)[0].should be_a_kind_of(Answer)
+  end
+  
+  it "should work, passing along references not clones to the original guys" do
+    twoGuys = @myGuesser.generate(2)
+    twoGuys[0].scores = {x2:612, x1:77, x3:712}
+    twoGuys[1].scores = {x2:2,   x1:3,  x3:4}
+    @myNondominatedScreener.generate(twoGuys).should include(twoGuys[1])
+    @myNondominatedScreener.generate(twoGuys).should_not include(twoGuys[0])
+    
+    
+    twoGuys[0].scores = {:x2 => 1, :x1 => 2, :x3 => 3}
+    twoGuys[1].scores = {:x2 => 2, :x1 => 1, :x3 => 3}
+    @myNondominatedScreener.generate(twoGuys).length.should == 2
+    @myNondominatedScreener.generate(twoGuys).should include(twoGuys[0])
+    @myNondominatedScreener.generate(twoGuys).should include(twoGuys[1])
+  end
+  
+  it "should work the same no matter what the scores hash order" do
+    twoGuys = @myGuesser.generate(2)
+    twoGuys[0].scores = {:x1 => 77, :x3 => 712,:x2 => 612}
+    twoGuys[1].scores = {:x2 => 2, :x1 => 3, :x3 => 4}
+    @myNondominatedScreener.generate(twoGuys).should include(twoGuys[1])
+    
+  end
+  
+  it "can use the 'template' parameter to compare individuals by a specified vector of scores" do
+    threeGuys = @myGuesser.generate(3)
+    threeGuys[0].scores = {:x1 => 1, :x2 => 2, :x3 => 3}
+    threeGuys[1].scores = {:x1 => 2, :x2 => 1, :x3 => 1}
+    threeGuys[2].scores = {:x1 => 4, :x2 => 0, :x3 => 2}
+    @myNondominatedScreener.generate(threeGuys).length.should == 3
+    @myNondominatedScreener.generate(threeGuys,[:x1]).length.should == 1
+    @myNondominatedScreener.generate(threeGuys,[:x1]).should include(threeGuys[0])
+    @myNondominatedScreener.generate(threeGuys,[:x2]).length.should == 1
+    @myNondominatedScreener.generate(threeGuys,[:x2]).should include(threeGuys[2])
+    @myNondominatedScreener.generate(threeGuys,[:x3]).length.should == 1
+    @myNondominatedScreener.generate(threeGuys,[:x3]).should include(threeGuys[1])
+    @myNondominatedScreener.generate(threeGuys,[:x1,:x3]).length.should == 2
+    @myNondominatedScreener.generate(threeGuys,[:x1,:x2]).length.should == 3
+    @myNondominatedScreener.generate(threeGuys,[:x2,:x3]).length.should == 2
+  end
+  
+  
+  it "should not include Answers in the resulting Batch that have not got the specified scores"
+  
+  
+  it "should use a default 'template' parameter that's the intersection of scores keys in the crowd" do
+    twoGuys = @myGuesser.generate(2)
+    twoGuys[0].scores = {x1:1, x2:2, x3:3}
+    twoGuys[1].scores = {      x2:0,      x4:12}
+    
+    @myNondominatedScreener.generate(twoGuys).length.should == 1
+    @myNondominatedScreener.generate(twoGuys).should include twoGuys[1]
+    @myNondominatedScreener.generate(twoGuys,[:x2]).length.should == 1
+  end
+  
+  it "should return Answers that belonged to crowd passed in" do
+    twoGuys = @myGuesser.generate(2)
+    orig_IDs = twoGuys.collect {|dude| dude.object_id}
+    twoGuys[0].scores = {:x1 => 1, :x2 => 2, :x3 => 3}
+    twoGuys[1].scores = {          :x2 => 1,           :x4 => 3}
+    @myNondominatedScreener.generate(twoGuys).length.should == 1
+    @myNondominatedScreener.generate(twoGuys).each {|newDude| orig_IDs.should include(newDude.object_id)}
+  end
+end

data/spec/operators/pointCrossover_spec.rb

@@ -0,0 +1,60 @@
+require File.join(File.dirname(__FILE__), "./../spec_helper")
+
+
+describe "PointCrossoverOperator" do
+  before(:each) do
+    @myXover = PointCrossoverOperator.new
+    @dude1 = Answer.new("block{do a \n do b\n do c}")
+    @dude2 = Answer.new("block{ref x \n ref y\n ref z}")
+  end
+  
+  it "should be a kind of SearchOperator" do
+    @myXover.should be_a_kind_of(SearchOperator)
+  end
+  
+  
+  describe "generate" do
+    
+    it "should take as a param a set of one or more Answers" do
+      lambda{@myXover.generate()}.should raise_error(ArgumentError)
+      lambda{@myXover.generate(331)}.should raise_error(ArgumentError)
+      lambda{@myXover.generate([])}.should raise_error(ArgumentError)
+      lambda{@myXover.generate([11])}.should raise_error(ArgumentError)
+      
+      lambda{@myXover.generate([@dude1])}.should_not raise_error(ArgumentError)
+    end
+    
+    it "should produce the same number of Answers it gets as a default" do
+      babies = @myXover.generate([@dude1])
+      babies.length.should == 1
+    end
+          
+    it "should have an optional parameter that specifies the number of offspring to produce per parent" do
+      babies = @myXover.generate(Batch.[](@dude1, @dude2))
+      babies.length.should == 2
+      babies = @myXover.generate([@dude1, @dude2],4)
+      babies.length.should == 8
+    end
+    
+    it "should only include points from one of the parents in the offspring blueprints" do
+      babies = @myXover.generate([@dude1, @dude2])
+      bothGenomes = @dude1.program.blueprint + @dude2.program.blueprint
+      babies.each do |baby|
+        baby.program.blueprint.each_line do |line|
+          bothGenomes.match(line.strip.delete("}")).should_not == nil
+        end
+      end
+    end
+    
+    it "should handle moving the footnotes correctly"
+    
+    it "should maintain unused footnotes correctly"
+    
+    it "should increment the offspring's progress from the max parents' progress" do
+      @dude1.stub(:progress).and_return(7)
+      @dude2.stub(:progress).and_return(11)
+      babies = @myXover.generate([@dude1, @dude2],10)
+      babies.each {|baby| [8,12].should include(baby.progress)}
+    end
+  end
+end