pest 0.0.0 → 0.1.0

data/spec/pest/data_set/narray_spec.rb

@@ -3,8 +3,6 @@ require 'narray'
 
 describe Pest::DataSet::NArray do
   before(:each) do
-    @v1 = Pest::Variable.new(:name => :foo)
-    @v2 = Pest::Variable.new(:name => :bar)
     @class = Pest::DataSet::NArray
   end
 
@@ -23,47 +21,30 @@ describe Pest::DataSet::NArray do
   end
 
   describe "::from_file" do
-    before(:each) do
-      @matrix = @class.from_hash @v1 => [1,2,3], @v2 => [4,5,6]
-      @file = Tempfile.new('test')
-      @matrix.save(@file.path)
-    end
-
-    it "loads from NArray IO" do
-      @class.from_file(@file).should == @matrix
-    end
-
-    it "looks for NArray from string" do
-      @class.from_file(@file.path).should == @matrix
-    end
-      
-    it "sets variables" do
-      @class.from_file(@file).variables.values.should == [@v1, @v2]
+    it "delegates to from_csv" do
+      @class.should_receive(:from_csv)
+      @class.from_file('foo')
     end
   end
 
   describe "::from_hash" do
     before(:each) do
-      @matrix = NArray.to_na [[4,5,6],[1,2,3]]
+      @matrix = NArray.to_na [[1,2,3],[4,5,6]]
     end
 
     it "creates a NArray" do
-      @class.from_hash({@v1 => [1,2,3], @v2 => [4,5,6]}).should == @matrix
+      @class.from_hash({:foo => [1,2,3], :bar => [4,5,6]}).data.should == @matrix
     end
 
     it "sets variables" do
-      @class.from_hash({@v1 => [1,2,3], @v2 => [4,5,6]}).variables.values.should == [@v1, @v2]
-    end
-
-    it "generates Pest::Variables if not passed" do
-      @class.from_hash({:foo => [1,2,3]}).variables[:foo].should be_a(Pest::Variable)
+      @class.from_hash({:foo => [1,2,3], :bar => [4,5,6]}).variables.should == [:foo, :bar].to_set
     end
   end
 
   describe "::from_csv" do
     before(:each) do
       @file = Tempfile.new('test_csv')
-      CSV.open(@file.path, 'w') do |csv|
+      CSV.open(@file.path, 'w', :col_sep => "\t") do |csv|
         csv << ["foo", "bar"]
         csv << [1,1]
         csv << [1,2]
@@ -73,22 +54,22 @@ describe Pest::DataSet::NArray do
 
     it "creates variables from first line" do
       @instance = @class.from_csv @file.path
-      @instance.variable_array.map(&:name).should == ["bar", "foo"]
+      @instance.variables.should == ["foo", "bar"].to_set
     end
 
     it "creates data from the rest" do
       @instance = @class.from_csv @file.path
-      @instance.to_hash.should == {@instance.variables["foo"] => [1,1,1], @instance.variables["bar"] => [1,2,3]}
+      @instance.to_hash.should == {"foo" => [1,1,1], "bar" => [1,2,3]}
     end
 
     it "accepts a filename" do
       @instance = @class.from_csv @file.path
-      @instance.to_hash.should == {@instance.variables["foo"] => [1,1,1], @instance.variables["bar"] => [1,2,3]}
+      @instance.to_hash.should == {"foo" => [1,1,1], "bar" => [1,2,3]}
     end
 
     it "accepts an IO" do
       @instance = @class.from_csv @file
-      @instance.to_hash.should == {@instance.variables["foo"] => [1,1,1], @instance.variables["bar"] => [1,2,3]}
+      @instance.to_hash.should == {"foo" => [1,1,1], "bar" => [1,2,3]}
     end
   end
 
@@ -98,44 +79,123 @@ describe Pest::DataSet::NArray do
     end
 
     it "sets keys" do
-      @instance.to_hash.keys.should == @instance.variables.values
+      @instance.to_hash.keys.to_set.should == @instance.variables
     end
 
     it "sets values" do
-      @instance.to_hash.values.should == [[4,5,6],[1,2,3]]
+      @instance.to_hash.values.should == [[1,2,3],[4,5,6]]
     end
   end
 
-  describe "#data_vectors" do
+  describe "#pick" do
     before(:each) do
       @instance = @class.from_hash :foo => [1,2,3], :bar => [4,5,6]
     end
 
-    it "returns an enumerable" do
-      @instance.data_vectors.should be_a(Enumerable)
+    it "accepts a single symbol string" do
+      @instance.pick(:foo).data.to_a.first.should == [1,2,3]
+    end
+
+    it "accepts a single variable" do
+      @instance.pick(:foo).data.to_a.first.should == [1,2,3]
+    end
+
+    it "accepts multiple variables" do
+      @instance.pick(:bar, :foo).data.to_a.should == [[4,5,6],[1,2,3]]
+   end
+  end
+
+  describe "#[]" do
+    before(:each) do
+      @all = @class.from_hash :foo => [1,2,3,4], :bar => [5,6,7,8]
+      @range_subset = @class.from_hash :foo => [1,2], :bar => [5,6]
+      @index_subset = @class.from_hash :foo => [4], :bar => [8]
+      @union_subset = @class.from_hash :foo => [4,1,2], :bar => [8,5,6]
+    end
+
+    context "with integer argument" do
+      it "returns a copy with the vector at the passed index" do
+        @all[3].should == @index_subset
+      end
+    end
+
+    context "with a range argument" do
+      it "returns a copy with the vectors specified by the range" do
+        @all[0..1].should == @range_subset
+      end
+    end
+
+    context "with multiple arguments" do
+      it "returns a copy with the union of the passed arguments" do
+        @all[3,0..1].should == @union_subset
+      end
+    end
+  end
+
+  describe "#+" do
+    before(:each) do
+      @all = @class.from_hash :foo => [1,2,4], :bar => [5,6,8]
+      @set_1 = @class.from_hash :foo => [1,2], :bar => [5,6]
+      @set_2 = @class.from_hash :foo => [4], :bar => [8]
     end
 
-    it "slices" do
-      # NOTE: This is returning an array - probably could be more efficient
-      @instance.data_vectors.first.should == [4,1]
+    it "returns the union of self and other" do
+      (@set_1 + @set_2).should == @all
     end
   end
 
-  describe "#save" do
+  describe "#each" do
     before(:each) do
-      @file = Tempfile.new('test')
       @instance = @class.from_hash :foo => [1,2,3], :bar => [4,5,6]
     end
 
-    it "marshals to file" do
-      @instance.save(@file)
-      @class.from_file(@file.path).should == @instance
+    it "yields vectors" do
+      block = double("block")
+      block.should_receive(:yielding).with([1,4])
+      block.should_receive(:yielding).with([2,5])
+      block.should_receive(:yielding).with([3,6])
+      @instance.each {|i| block.yielding(i)}
+    end
+  end
+
+  describe "#map" do
+    before(:each) do
+      @instance = @class.from_hash :foo => [1,2,3], :bar => [4,5,6]
+    end
+
+    it "works" do
+      @instance.map {|i| i}.should == [[1,4],[2,5],[3,6]]
+    end
+  end
+
+  describe "#merge" do
+    before(:each) do
+      @other    = @class.from_hash :foo => [10,11,12,13], :baz => [1,2,3,4]
+      @instance = @class.from_hash :foo => [1,2,3,4], :bar => [5,6,7,8]
+    end
+
+    it "accepts a dataset and returns dataset" do
+      @instance.merge(@other).should be_a(@class)
+    end
+
+    it "accepts a hash and returns dataset" do
+      @instance.merge(:foo => [10,11,12,13], :baz => [1,2,3,4]).should be_a(@class)
+    end
+
+    it "requires the dataset to have the same length" do
+      expect { @instance.merge(:foo => [1,2,3,4,5]) }.to raise_error(ArgumentError)
+    end
+
+    it "adds the passed variable to self" do
+      @instance.merge(@other).variables.should include(:baz)
+    end
+
+    it "adds the passed data to self" do
+      @instance.merge(@other).pick(:baz).to_a.should == [1,2,3,4]
     end
 
-    it "saves to tmp dir if no filename specified" do
-      Tempfile.should_receive(:new).and_return(@file)
-      @instance.save
-      @class.from_file(@file.path).should == @instance
+    it "over-writes variables in self with variables in other" do
+      @instance.merge(@other).pick(:foo).to_a.should == [10,11,12,13]
     end
   end
 end

data/spec/pest/data_set_spec.rb

@@ -91,5 +91,40 @@ describe Pest::DataSet do
     end
   end
 
-  # Enumerable interface?
+  describe "#[]" do
+    context "with a single argument" do
+      it "returns NotImplementedError" do
+        expect { @instance[1] }.to raise_error(NotImplementedError)
+      end
+    end
+
+    context "with multiple arguments" do
+      it "returns NotImplementedError" do
+        expect { @instance[1,5] }.to raise_error(NotImplementedError)
+      end
+    end
+  end
+
+  describe "#+" do
+    it "returns NotImplementedError" do
+      expect { @instance + @instance }.to raise_error(NotImplementedError)
+    end
+  end
+
+  it "inherits from Enumerable" do
+    @instance = TestClass.new
+    @instance.should be_a(Enumerable)
+  end
+
+  describe "#each" do
+    it "yields vectors" do
+      expect { @instance.each {} }.to raise_error(NotImplementedError)
+    end
+  end
+
+  describe "#merge" do
+    it "returns NotImplementedError" do
+      expect { @instance.merge(@instance) }.to raise_error(NotImplementedError)
+    end
+  end
 end

data/spec/pest/estimator/frequency_spec.rb

@@ -3,10 +3,8 @@ require 'spec_helper'
 describe Pest::Estimator::Frequency do
   before(:each) do
     @class = Pest::Estimator::Frequency
-    @v1 = Pest::Variable.new(:name => :foo)
-    @v2 = Pest::Variable.new(:name => :bar)
-    @data = Pest::DataSet::NArray.from_hash @v1 => [1,1,2,3], @v2 => [1,1,1,1]
-    @test = Pest::DataSet::NArray.from_hash @v1 => [1,2,4], @v2 => [1,1,1]
+    @data = Pest::DataSet::NArray.from_hash :foo => [1,1,2,3], :bar => [1,1,1,1]
+    @test = Pest::DataSet::NArray.from_hash :foo => [1,2,4], :bar => [1,1,1]
     @instance = @class.new(@data)
   end
 
@@ -15,56 +13,57 @@ describe Pest::Estimator::Frequency do
   end
 
   it "generates marginal probabilities" do
-    @instance.p(@v2).in(@test).should === NArray[[1.0, 1.0, 1.0]]
+    @instance.p(:bar => 1).should == 1.0
   end
 
   it "generates joint probability" do
-    @instance.p(@v1, @v2).in(@test).should == NArray[[0.5, 0.25, 0]]
+    @instance.p(:foo => 2, :bar => 1).should == 0.25
   end
 
   it "generates conditional probability" do
-    @instance.p(@v1).given(@v2).in(@test).should == NArray[[0.5, 0.25, 0]]
+    @instance.p(:foo => 2).given(:bar => 1).should == 0.25
+  end
+
+  it "generates marginal batch_probabilities" do
+    @instance.batch_p(:bar).in(@test).should == [1.0, 1.0, 1.0]
+  end
+
+  it "generates joint batch_probability" do
+    @instance.batch_p(:foo, :bar).in(@test).should == [0.5, 0.25, 0]
+  end
+
+  it "generates conditional batch_probability" do
+    @instance.batch_p(:foo).given(:bar).in(@test).should == [0.5, 0.25, 0]
   end
 
   describe Pest::Estimator::Frequency::Distribution do
     before(:each) do
-      @dist = @instance.distributions[@data.variables.values.to_set]
+      @dist = @instance.distributions[*@data.variables]
     end
 
     describe "#cache_model" do
-      context "with unrecognized checksum" do
-        it "determines vector frequency" do
-          @dist.cache_model
-          @dist.frequencies[[1,1]].should == 2
-        end
-
-        it "defaults to 0" do
-          @dist.cache_model
-          @dist.frequencies[[4,1]].should == 0
-        end
-      end
-
-      context "with recognized checksum but no file" do
-        it "determines vector frequency" do
-          @data.should_receive(:data_vectors).and_return @data
-          @dist.cache_model
-        end
+      it "determines vector frequency" do
+        @dist.cache_model
+        @dist.frequencies[[1,1]].should == 2
       end
 
-      context "with recognized checksum and cache file" do
-        before(:each) do
-          @file = @dist.cache_model
-        end
+      it "defaults to 0" do
+        @dist.cache_model
+        @dist.frequencies[[4,1]].should == 0
       end
     end
 
     describe "#probability" do
-      it "returns an NArray" do
+      before(:each) do
+        @test = Pest::DataSet::Hash.from_hash(:foo => [1], :bar => [1])
+      end
+
+      it "returns an float" do
         @dist.probability(@test).should be_a(NArray)
       end
 
-      it "calculates vector frequency / dataset length"  do
-        @dist.probability(@test).should == NArray[[0.5,0.25,0]]        
+      it "calculates frequency / dataset length"  do
+        @dist.probability(@test).to_a.should == [0.5]
       end
     end
     

data/spec/pest/estimator_spec.rb

@@ -28,32 +28,28 @@ describe Pest::Estimator do
 
   describe "#estimates" do
     before(:each) do
-      @v1 = Pest::Variable.new(:name => :foo)
-      @v2 = Pest::Variable.new(:name => :bar)
-      @v3 = Pest::Variable.new(:name => :baz)
-
       @instance = TestClass.new
-      @instance.stub(:variables).and_return({:foo => @v1, :bar => @v2})
+      @instance.stub(:variables).and_return([:foo, :bar].to_set)
     end
 
     it "accepts a set of variables" do
-      @instance.distributions[@v1, @v2].should be_a(Pest::Estimator::Distribution)
+      @instance.distributions[:foo, :bar].should be_a(Pest::Estimator::Distribution)
     end
 
     it "returns an estimator for the passed variables" do
-      @instance.distributions[@v1, @v2].variables.should == [@v1, @v2].to_set
+      @instance.distributions[:foo, :bar].variables.should == [:foo, :bar].to_set
     end
 
     it "returns an estimator for the passed strings" do
-      @instance.distributions[:foo, :bar].variables.should == [@v1, @v2].to_set
+      @instance.distributions[:foo, :bar].variables.should == [:foo, :bar].to_set
     end
 
     it "is variable order agnostic" do
-      @instance.distributions[@v1, @v2].should == @instance.distributions[@v2, @v1]
+      @instance.distributions[:foo, :bar].should == @instance.distributions[:bar, :foo]
     end
 
     it "fails if a set variable isn't defined" do
-      lambda { @instance.distributions[@v1, @v3] }.should raise_error(ArgumentError)
+      lambda { @instance.distributions[:foo, :baz] }.should raise_error(ArgumentError)
     end
   end
 
@@ -61,10 +57,16 @@ describe Pest::Estimator do
     before(:each) do
       @class = TestClass::Distribution
       @estimator = TestClass.new
-      @estimator.stub(:variables).and_return({:foo => @v1, :bar => @v2})
+      @estimator.stub(:variables).and_return({:foo => :foo, :bar => :bar})
       @instance = @class.new(@estimator, @estimator.variables) 
     end
 
+    describe "#batch_probability" do
+      it "raises no implemented" do
+        expect { @instance.batch_probability }.to raise_error(NotImplementedError)
+      end
+    end
+
     describe "#probability" do
       it "raises no implemented" do
         expect { @instance.probability }.to raise_error(NotImplementedError)

data/spec/pest/function/entropy_spec.rb

@@ -7,11 +7,8 @@ end
 
 describe Pest::Function::Entropy do
   before(:each) do
-    @v1 = Pest::Variable.new(:name => :foo)
-    @v2 = Pest::Variable.new(:name => :bar)
-    @v3 = Pest::Variable.new(:name => :baz)
     @instance = EntropyTestClass.new
-    @instance.stub(:variables).and_return({:foo => @v1, :bar => @v2})
+    @instance.stub(:variables).and_return([:foo, :bar].to_set)
   end
 
   describe "#entropy" do
@@ -26,18 +23,18 @@ describe Pest::Function::Entropy do
 
   describe Pest::Function::Entropy::Builder do
     describe "::new" do
-      before(:each) { @builder = EntropyTestClass::Builder.new(@instance, [@v1, :bar]) }
+      before(:each) { @builder = EntropyTestClass::Builder.new(@instance, [:foo, :bar]) }
 
       it "sets estimator" do
         @builder.estimator.should == @instance
       end
 
       it "sets event" do
-        @builder.event.should == [@v1, @v2].to_set
+        @builder.event.should == [:foo, :bar].to_set
       end
 
       it "fails if variable undefined for estimator" do
-        lambda { EntropyTestClass::Builder.new(@instance, [@v1, @v3]) }.should raise_error(ArgumentError)
+        lambda { EntropyTestClass::Builder.new(@instance, [:foo, :baz]) }.should raise_error(ArgumentError)
       end
 
       it "constructs dataset if passed hash"
@@ -48,7 +45,7 @@ describe Pest::Function::Entropy do
 
       it "sets givens" do
         @builder.given(:bar)
-        @builder.givens.should include(@v2)
+        @builder.givens.should include(:bar)
       end
 
       it "returns self" do
@@ -69,7 +66,7 @@ describe Pest::Function::Entropy do
 
       it "gets entropy of event" do
         event = double('EntropyEventDist')
-        @instance.distributions.stub(:[]).with([@v1].to_set).and_return(event)
+        @instance.distributions.stub(:[]).with([:foo].to_set).and_return(event)
         event.should_receive(:entropy).and_return 0.5
 
         EntropyTestClass::Builder.new(@instance,[:foo]).evaluate
@@ -78,8 +75,8 @@ describe Pest::Function::Entropy do
       it "gets entropy of givens" do
         event = double("EntropyEventDist", :entropy => 0.5)
         given = double("EntropyGivenDist", :entropy => 0.25)
-        @instance.distributions.stub(:[]).with([@v1].to_set).and_return(event)
-        @instance.distributions.stub(:[]).with([@v2].to_set).and_return(given)
+        @instance.distributions.stub(:[]).with([:foo].to_set).and_return(event)
+        @instance.distributions.stub(:[]).with([:bar].to_set).and_return(given)
         given.should_receive(:entropy).and_return 0.25
 
         EntropyTestClass::Builder.new(@instance,[:foo]).given(:bar).evaluate
@@ -88,15 +85,15 @@ describe Pest::Function::Entropy do
       it "returns H event - givens (if givens)" do
         event = double("EntropyEventDist", :entropy => 0.5)
         given = double("EntropyGivenDist", :entropy => 0.1)
-        @instance.distributions.stub(:[]).with([@v1].to_set).and_return(event)
-        @instance.distributions.stub(:[]).with([@v2].to_set).and_return(given)
+        @instance.distributions.stub(:[]).with([:foo].to_set).and_return(event)
+        @instance.distributions.stub(:[]).with([:bar].to_set).and_return(given)
 
         EntropyTestClass::Builder.new(@instance,[:foo]).given(:bar).evaluate.should == 0.4
       end
 
       it "returns H event (if no givens)" do
         event = double("EntropyEventDist", :entropy => 0.5)
-        @instance.distributions.stub(:[]).with([@v1].to_set).and_return(event)
+        @instance.distributions.stub(:[]).with([:foo].to_set).and_return(event)
 
         EntropyTestClass::Builder.new(@instance,[:foo]).evaluate.should == 0.5
       end