accumulators 0.2.0 → 0.3.0

data/Gemfile.lock

@@ -2,7 +2,7 @@ GEM
   remote: http://rubygems.org/
   specs:
     diff-lcs (1.1.2)
-    ffi (1.0.8)
+    ffi (1.0.9)
     git (1.2.5)
     growl (1.0.3)
     guard (0.3.4)
@@ -13,8 +13,8 @@ GEM
       bundler (~> 1.0.0)
       git (>= 1.2.5)
       rake
-    libnotify (0.3.0)
-      ffi (>= 0.6.2)
+    libnotify (0.5.2)
+      ffi (~> 1.0)
     rake (0.9.0)
     rb-fsevent (0.4.0)
     rb-inotify (0.8.4)
@@ -24,7 +24,7 @@ GEM
       rspec-core (~> 2.6.0)
       rspec-expectations (~> 2.6.0)
       rspec-mocks (~> 2.6.0)
-    rspec-core (2.6.1)
+    rspec-core (2.6.2)
     rspec-expectations (2.6.0)
       diff-lcs (~> 1.1.2)
     rspec-mocks (2.6.0)

data/Guardfile

@@ -6,9 +6,4 @@ guard 'rspec', :version => 2 do
   watch(%r{^lib/(.+)\.rb})     { |m| "spec/lib/#{m[1]}_spec.rb" }
   watch('spec/spec_helper.rb') { "spec" }
 
-  # Rails example
-  watch(%r{^spec/.+_spec\.rb})
-  watch(%r{^app/(.+)\.rb})                           { |m| "spec/#{m[1]}_spec.rb" }
-  watch(%r{^lib/(.+)\.rb})                           { |m| "spec/lib/#{m[1]}_spec.rb" }
-  watch(%r{^app/controllers/(.+)_(controller)\.rb})  { |m| ["spec/routing/#{m[1]}_routing_spec.rb", "spec/#{m[2]}s/#{m[1]}_#{m[2]}_spec.rb", "spec/acceptance/#{m[1]}_spec.rb"] }
 end

data/VERSION

@@ -1 +1 @@
-0.2.0
+0.3.0

data/accumulators.gemspec

@@ -5,7 +5,7 @@
 
 Gem::Specification.new do |s|
   s.name = %q{accumulators}
-  s.version = "0.2.0"
+  s.version = "0.3.0"
 
   s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
   s.authors = ["Gavin Heavyside"]
@@ -27,16 +27,13 @@ Gem::Specification.new do |s|
     "Rakefile",
     "VERSION",
     "accumulators.gemspec",
-    "features/accumulators.feature",
-    "features/step_definitions/accumulators_steps.rb",
-    "features/support/env.rb",
     "lib/accumulators.rb",
     "lib/accumulators/count.rb",
     "lib/accumulators/mean.rb",
-    "lib/accumulators/meanvariance.rb",
-    "spec/accumulators/count_spec.rb",
-    "spec/accumulators/mean_spec.rb",
-    "spec/accumulators/meanvariance_spec.rb",
+    "lib/accumulators/mean_variance.rb",
+    "spec/lib/accumulators/count_spec.rb",
+    "spec/lib/accumulators/mean_spec.rb",
+    "spec/lib/accumulators/mean_variance_spec.rb",
     "spec/spec_helper.rb"
   ]
   s.homepage = %q{http://github.com/hgavin/accumulators}

data/lib/accumulators.rb

@@ -1,6 +1,6 @@
 module Accumulators
   autoload :Count, "accumulators/count"
   autoload :Mean, "accumulators/mean"
-  autoload :MeanVariance, "accumulators/meanvariance"
+  autoload :MeanVariance, "accumulators/mean_variance"
 end
 

data/lib/accumulators/mean.rb

@@ -19,7 +19,7 @@ module Accumulators
         @count = @count + rhs.count
         @mean = (sum + rhs_sum) / @count
       else
-        raise ArgumentError.new("Can only add numbers to a Mean Accumulator")
+        raise ArgumentError.new("You may not add #{rhs.class} to #{self.class}")
       end
     end
   end

data/lib/accumulators/{meanvariance.rb → mean_variance.rb}

@@ -28,16 +28,24 @@ module Accumulators
           @sumsq = newSumsq
         end
       else
-        raise ArgumentError
+        raise ArgumentError.new("You may not add #{rhs.class} to #{self.class}")
       end
     end
 
-    def variance
-      @count > 1 ? (@sumsq / (@count)) : 0.0
+    def variance(options = {})
+      if options[:type] and not [:sample, :population].include? options[:type]
+        raise ArgumentError.new("type must be one of :sample, :population")
+      end
+
+      if options[:type] == :population
+        @count > 1 ? (@sumsq / (@count)) : 0.0
+      else
+        @count > 1 ? (@sumsq / (@count + 1)) : 0.0
+      end
     end
 
-    def stddev
-      Math.sqrt(variance)
+    def stddev(options = {})
+      Math.sqrt(variance(options))
     end
 
   end

data/spec/{accumulators → lib/accumulators}/count_spec.rb

@@ -1,60 +1,58 @@
 require 'spec_helper'
 
-describe "Accumulators" do
-  describe "Count" do
-    before :each do
-      @count = Accumulators::Count.new
-    end
+module Accumulators
+  describe Count do
+    let(:count){Count.new}
 
     context "Creation" do
       it "can be created" do
-        lambda{ Accumulators::Count.new }.should_not raise_error
+        lambda{ Count.new }.should_not raise_error
       end
 
       it "returns count of 0 before anything is added to it" do
-        Accumulators::Count.new.count.should == 0
+        Count.new.count.should == 0
       end
     end
 
     context "adding numbers or distributions" do
       it "allows integers to be added" do
-        lambda{@count.add 5}.should_not raise_error
+        lambda{count.add 5}.should_not raise_error
       end
 
       it "allows floats to be added" do
-        lambda{@count.add 3.4}.should_not raise_error
+        lambda{count.add 3.4}.should_not raise_error
       end
 
       it "allows other Count distributions to be added" do
-        c2 = Accumulators::Count.new
-        lambda{@count.add c2}.should_not raise_error
+        c2 = Count.new
+        lambda{count.add c2}.should_not raise_error
       end
 
       it "allows strings to be added" do
-        lambda{@count.add "1.5"}.should_not raise_error
+        lambda{count.add "1.5"}.should_not raise_error
       end
     end
 
     context "correctness of item additions" do
       it "should return a count of 1 when a single item is added" do
-        @count.add 5
-        @count.count.should == 1
+        count.add 5
+        count.count.should == 1
       end
 
       it "should return the count of how many items have been added" do
         1.upto(1000) do |i|
-          @count.add i
-          @count.count.should == i
+          count.add i
+          count.count.should == i
         end
       end
     end
 
     context "correctness of accumulator additions" do
       it "should combine two Count accumulators correctly" do
-        c2 = Accumulators::Count.new
-        10.times{ c2.add 1; @count.add 1 }
-        @count.add(c2)
-        @count.count.should == 20
+        c2 = Count.new
+        10.times{ c2.add 1; count.add 1 }
+        count.add(c2)
+        count.count.should == 20
       end
     end
   end

data/spec/{accumulators → lib/accumulators}/mean_spec.rb

@@ -1,96 +1,96 @@
 require 'spec_helper'
 
-describe "Accumulators" do
-  describe "Mean" do
-    before :each do
-      @mean = Accumulators::Mean.new
-    end
+module Accumulators
+  describe Mean do
+    let(:mean){Mean.new}
 
     context "Creation" do
       it "can be created" do
-        lambda{ Accumulators::Mean.new}.should_not raise_error
+        lambda{ Mean.new}.should_not raise_error
       end
 
       it "returns count and mean of 0 before anything is added to it" do
-        @mean.count.should == 0
-        @mean.mean.should be_within(EPSILON).of(0.0)
+        mean.count.should == 0
+        mean.mean.should be_within(EPSILON).of(0.0)
       end
 
     end
 
     context "adding numbers or distributions" do
       it "allows integers to be added" do
-        lambda{@mean.add 5}.should_not raise_error
+        lambda{mean.add 5}.should_not raise_error
       end
 
       it "allows floats to be added" do
-        lambda{@mean.add 3.4}.should_not raise_error
+        lambda{mean.add 3.4}.should_not raise_error
       end
 
       it "allows other Mean distributions to be added" do
-        mean2 = Accumulators::Mean.new
-        lambda{@mean.add mean2}.should_not raise_error
+        mean2 = Mean.new
+        lambda{mean.add mean2}.should_not raise_error
       end
 
       it "raises an ArgumentError if a string is added" do
-        lambda{@mean.add "1.5"}.should raise_error(ArgumentError)
+        lambda{mean.add "1.5"}.should raise_error(
+          ArgumentError,
+          "You may not add String to Accumulators::Mean")
       end
     end
 
     context "correctness of int additions" do
       it "should return count of 1 and mean of 5 when 5 is added" do
-        @mean.add(5)
-        @mean.count.should == 1
-        @mean.mean.should be_within(EPSILON).of(5)
+        mean.add(5)
+        mean.count.should == 1
+        mean.mean.should be_within(EPSILON).of(5)
       end
 
       it "should calculate the mean correctly for a set of integers" do
-        1.upto(10) {|i| @mean.add i}
-        @mean.count.should == 10
-        @mean.mean.should be_within(EPSILON).of((1..10).reduce(:+).to_f/10)
+        1.upto(10) {|i| mean.add i}
+        mean.count.should == 10
+        mean.mean.should be_within(EPSILON).of((1..10).reduce(:+).to_f/10)
       end
 
       it "should calculate the mean correctly for a random set of 1000 integers" do
         vals = []
         1000.times do
           vals << rand(100000)
-          @mean.add(vals.last)
+          mean.add(vals.last)
         end
 
-        @mean.mean.should be_within(EPSILON).of(vals.reduce(:+).to_f/vals.size)
+        mean.mean.should be_within(EPSILON).of(vals.reduce(:+).to_f/vals.size)
       end
     end
 
     context "correctness of float additions" do
       it "should calculate the mean correctly for a set of floats" do
-        1.upto(10) {|i| @mean.add i+0.1}
-        @mean.count.should == 10
-        @mean.mean.should be_within(EPSILON).of((1..10).map{|i| i+0.1}.reduce(:+)/10)
+        1.upto(10) {|i| mean.add i+0.1}
+        mean.count.should == 10
+        mean.mean.should be_within(EPSILON).of((1..10).map{|i| i+0.1}.reduce(:+)/10)
       end
 
       it "should calculate the mean correctly for a random set of 1000 floats" do
         vals = []
         1000.times do
           vals << rand * 1000000
-          @mean.add vals.last
+          mean.add vals.last
         end
-        @mean.mean.should be_within(EPSILON).of(vals.reduce(:+)/vals.size)
+        mean.mean.should be_within(EPSILON).of(vals.reduce(:+)/vals.size)
       end
     end
 
     context "correctness of accumulator additions" do
       it "should combine two means correctly" do
-        m2 = Accumulators::Mean.new
+        m2 = Mean.new
         vals = []
         500.times do
           vals << rand * 1000000
-          @mean.add vals.last
+          mean.add vals.last
           vals << rand * 100000
           m2.add vals.last
         end
-        @mean.add(m2)
-        @mean.count.should == 1000
-        @mean.mean.should be_within(EPSILON).of(vals.reduce(:+)/vals.size)
+        mean.add(m2)
+        mean.count.should == 1000
+        mean.mean.should be_within(EPSILON).of(vals.reduce(:+)/vals.size)
       end
     end
   end

data/spec/lib/accumulators/mean_variance_spec.rb

@@ -0,0 +1,102 @@
+require 'spec_helper'
+
+module Accumulators
+  describe MeanVariance do
+    let(:meanvar){MeanVariance.new}
+
+    context "When creating" do
+      it "can be created" do
+        lambda{ MeanVariance.new }.should_not raise_error
+      end
+
+      it "returns count,mean,var of 0,0.0,0.0 before anything is added" do
+        meanvar.count.should == 0
+        meanvar.mean.should be_within(EPSILON).of(0.0)
+        meanvar.variance(type: :population).should be_within(EPSILON).of(0.0)
+      end
+    end
+
+    context "When adding numbers or distributions" do
+      it "allows integers to be added" do
+        lambda{ meanvar.add 5 }.should_not raise_error
+      end
+
+      it "allows floats to be added" do
+        lambda{ meanvar.add 5.5 }.should_not raise_error
+      end
+
+      it "allows other MeanVar distributions to be added" do
+        lambda{ meanvar.add MeanVariance.new }.should_not raise_error
+      end
+
+      it "raises an ArgumentError if a string is added" do
+        lambda{ meanvar.add "1.5" }.should raise_error(
+          ArgumentError,
+          "You may not add String to Accumulators::MeanVariance")
+      end
+
+      it "raises an ArgumentError if a Mean accumulator is added" do
+        lambda{ meanvar.add Mean.new }.should raise_error(
+          ArgumentError,
+          "You may not add Accumulators::Mean to Accumulators::MeanVariance")
+      end
+
+      it "raises an ArgumentError if an unknown type of variance is requested" do
+        lambda{ meanvar.variance(type: :unknown) }.should raise_error(
+          ArgumentError,
+          "type must be one of :sample, :population")
+      end
+    end
+
+    context "When checking correctness of biased/population calculations" do
+      before do
+        @vals = []
+        1000.times do
+          @vals << rand * 10000
+          meanvar.add @vals.last
+        end
+      end
+
+      it "calculates the count and mean correctly for a set of numbers" do
+        meanvar.count.should == @vals.size
+        meanvar.mean.should be_within(EPSILON).of(@vals.reduce(:+)/@vals.size)
+      end
+
+      it "calculates the population variance and stddev correctly" do
+        variance = @vals.map{|v| (v - meanvar.mean)**2}.reduce(:+) / @vals.size 
+        meanvar.variance(type: :population).should be_within(EPSILON).of(variance)
+        meanvar.stddev(type: :population).should be_within(EPSILON).of(Math.sqrt(variance))
+      end
+
+      it "calculates the sample variance and stddev correctly" do
+        variance = @vals.map{|v| (v - meanvar.mean)**2}.reduce(:+) / (@vals.size + 1)
+        meanvar.variance(type: :sample).should be_within(EPSILON).of(variance)
+        meanvar.stddev(type: :sample).should be_within(EPSILON).of(Math.sqrt(variance))
+      end
+
+      it "defaults to sample variance" do
+        meanvar.variance.should be_within(EPSILON).of(meanvar.variance(type: :sample))
+      end
+    end
+
+    context "When combining MeanVariances" do
+      it "combines two MeanVariances correctly" do
+        vals = []
+        mv2 = MeanVariance.new
+        500.times do
+          vals << rand * 10000
+          meanvar.add vals.last
+          vals << rand * 1000
+          mv2.add vals.last
+        end
+
+        meanvar.add(mv2)
+
+        meanvar.count.should == vals.size
+        meanvar.mean.should be_within(EPSILON).of(vals.reduce(:+)/vals.size)
+        meanvar.variance(type: :population).should be_within(EPSILON).of(vals.map{|v| (v - meanvar.mean)**2}.reduce(:+) / vals.size)
+      end
+    end
+
+  end
+end

metadata

@@ -2,7 +2,7 @@
 name: accumulators
 version: !ruby/object:Gem::Version 
   prerelease: 
-  version: 0.2.0
+  version: 0.3.0
 platform: ruby
 authors: 
 - Gavin Heavyside
@@ -99,16 +99,13 @@ files:
 - Rakefile
 - VERSION
 - accumulators.gemspec
-- features/accumulators.feature
-- features/step_definitions/accumulators_steps.rb
-- features/support/env.rb
 - lib/accumulators.rb
 - lib/accumulators/count.rb
 - lib/accumulators/mean.rb
-- lib/accumulators/meanvariance.rb
-- spec/accumulators/count_spec.rb
-- spec/accumulators/mean_spec.rb
-- spec/accumulators/meanvariance_spec.rb
+- lib/accumulators/mean_variance.rb
+- spec/lib/accumulators/count_spec.rb
+- spec/lib/accumulators/mean_spec.rb
+- spec/lib/accumulators/mean_variance_spec.rb
 - spec/spec_helper.rb
 has_rdoc: true
 homepage: http://github.com/hgavin/accumulators
@@ -124,7 +121,7 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements: 
   - - ">="
     - !ruby/object:Gem::Version 
-      hash: -274752833993731131
+      hash: -417395174434128828
       segments: 
       - 0
       version: "0"

data/features/accumulators.feature

@@ -1,9 +0,0 @@
-Feature: something something
-  In order to something something
-  A user something something
-  something something something
-
-  Scenario: something something
-    Given inspiration
-    When I create a sweet new gem
-    Then everyone should see how awesome I am

data/features/support/env.rb

@@ -1,13 +0,0 @@
-require 'bundler'
-begin
-  Bundler.setup(:default, :development)
-rescue Bundler::BundlerError => e
-  $stderr.puts e.message
-  $stderr.puts "Run `bundle install` to install missing gems"
-  exit e.status_code
-end
-
-$LOAD_PATH.unshift(File.dirname(__FILE__) + '/../../lib')
-require 'accumulators'
-
-require 'rspec/expectations'

data/spec/accumulators/meanvariance_spec.rb

@@ -1,78 +0,0 @@
-require 'spec_helper'
-
-
-describe "Accumulators" do
-  describe "MeanVariance" do
-    before :each do
-      @meanvar = Accumulators::MeanVariance.new
-    end
-
-    context "Creation" do
-      it "can be created" do
-        lambda{ Accumulators::MeanVariance.new }.should_not raise_error
-      end
-
-      it "returns count,mean,var of 0,0.0,0.0 before anything is added" do
-        @meanvar.count.should == 0
-        @meanvar.mean.should be_within(EPSILON).of(0.0)
-        @meanvar.variance.should be_within(EPSILON).of(0.0)
-      end
-    end
-
-    context "adding numbers or distributions" do
-      it "allows integers to be added" do
-        lambda{ @meanvar.add 5 }.should_not raise_error
-      end
-
-      it "allows floats to be added" do
-        lambda{ @meanvar.add 5.5 }.should_not raise_error
-      end
-
-      it "allows other MeanVar distributions to be added" do
-        lambda{ @meanvar.add Accumulators::MeanVariance.new }.should_not raise_error
-      end
-
-      it "raises an ArgumentError if a string is added" do
-        lambda{ @meanvar.add "1.5" }.should raise_error(ArgumentError)
-      end
-
-      it "raises an ArgumentError if a Mean accumulator is added" do
-        lambda{ @meanvar.add Accumulators::Mean.new }.should raise_error(ArgumentError)
-      end
-    end
-
-    context "correctness of calcs when adding numbers" do
-      it "should calculate the mean and variance correctly for a set of numbers" do
-        vals = []
-        1000.times do
-          vals << rand * 10000
-          @meanvar.add vals.last
-        end
-
-        @meanvar.count.should == vals.size
-        @meanvar.mean.should be_within(EPSILON).of(vals.reduce(:+)/vals.size)
-        @meanvar.variance.should be_within(EPSILON).of(vals.map{|v| (v - @meanvar.mean)**2}.reduce(:+) / vals.size)
-      end
-    end
-
-    context "correctness of calcs when adding MeanVariance accumulators" do
-      it "should combine two MeanVariances correctly" do
-        vals = []
-        mv2 = Accumulators::MeanVariance.new
-        500.times do
-          vals << rand * 10000
-          @meanvar.add vals.last
-          vals << rand * 1000
-          mv2.add vals.last
-        end
-
-        @meanvar.add(mv2)
-
-        @meanvar.count.should == vals.size
-        @meanvar.mean.should be_within(EPSILON).of(vals.reduce(:+)/vals.size)
-        @meanvar.variance.should be_within(EPSILON).of(vals.map{|v| (v - @meanvar.mean)**2}.reduce(:+) / vals.size)
-      end
-    end
-
-  end
-end