standard_deviation 1.0.0 → 1.0.1

data/.travis.yml

@@ -0,0 +1,8 @@
+language: ruby
+rvm:
+  - 1.8.7
+  - 1.9.2
+  - 1.9.3
+  - rbx-18mode
+  - rbx-19mode
+  - ree

data/README.md

@@ -2,6 +2,8 @@
 
 An implementation of the standard deviation calculation in C, with much better performance (50x-100x) than using pure ruby.
 
+[![Build Status](https://secure.travis-ci.org/reu/fonte.png)](http://travis-ci.org/reu/standard_deviation)
+
 ## Installation
 
 Add this line to your application's Gemfile:
@@ -32,6 +34,7 @@ For population standard deviation, call `stdevp`:
 ```
 
 Also, the API exposes the `sample_variance` and `population_variance` calculations:
+
 ``` ruby
 [1, 2, 3, 4, 5].sample_variance => 2.5
 [1, 2, 3, 4, 5].population_variance => 2.0

data/benchmark/bigdecimal.rb

@@ -0,0 +1,26 @@
+require "standard_deviation"
+require "benchmark"
+require 'bigdecimal'
+
+class Array
+  def stdev_ruby
+    total = inject :+
+    mean  = total.to_f / size
+    variance = inject(0) { |variance, value| variance + (value - mean) ** 2 } / (size - 1)
+
+    Math.sqrt(variance)
+  end
+end
+
+n = 50
+values = (1..10_000).map { |value| BigDecimal.new [value, (rand * 10000000000).to_i].join(".") }
+
+Benchmark.bm do |b|
+  b.report do
+    n.times { values.stdev }
+  end
+
+  b.report do
+    n.times { values.stdev_ruby }
+  end
+end

data/benchmark/ruby_version.rb

@@ -0,0 +1,25 @@
+require "standard_deviation"
+require "benchmark"
+
+class Array
+  def stdev_ruby
+    total = inject :+
+    mean  = total.to_f / size
+    variance = inject(0) { |variance, value| variance + (value - mean) ** 2 } / (size - 1)
+
+    Math.sqrt(variance)
+  end
+end
+
+n = 1000
+values = (1..10_000).map(&:to_f)
+
+Benchmark.bm do |b|
+  b.report do
+    n.times { values.stdev }
+  end
+
+  b.report do
+    n.times { values.stdev_ruby }
+  end
+end

data/benchmark/types.rb

@@ -0,0 +1,24 @@
+require "standard_deviation"
+require "bigdecimal"
+require "benchmark"
+
+n = 100
+range =  (1..10_000)
+
+integers = range.to_a
+floats   = range.map(&:to_f)
+decimals = range.map { |value| BigDecimal.new [value, (rand * 10000000000).to_i].join(".") }
+
+Benchmark.bm do |b|
+  b.report do
+    n.times { integers.stdev }
+  end
+
+  b.report do
+    n.times { floats.stdev }
+  end
+
+  b.report do
+    n.times { decimals.stdev }
+  end
+end

data/ext/standard_deviation/standard_deviation.c

@@ -1,7 +1,7 @@
 #include <ruby.h>
 #include <math.h>
 
-static double sum(VALUE *array, int size) {
+static double sum(VALUE *array, long size) {
   int i;
   double total = 0;
 
@@ -12,7 +12,7 @@ static double sum(VALUE *array, int size) {
   return total;
 }
 
-static double distance_from_mean(VALUE *array, int size) {
+static double distance_from_mean(VALUE *array, long size) {
   int i;
   double mean, distance;
 
@@ -25,39 +25,51 @@ static double distance_from_mean(VALUE *array, int size) {
   return distance;
 }
 
-static double compute_sample_variance(VALUE *array, int size) {
+static double compute_sample_variance(VALUE *array, long size) {
   return distance_from_mean(array, size) / (size - 1);
 }
 
-static double compute_population_variance(VALUE *array, int size) {
+static double compute_population_variance(VALUE *array, long size) {
   return distance_from_mean(array, size) / size;
 }
 
+static void raise_not_enough_elements() {
+  rb_raise(rb_eZeroDivError, "not enough elements");
+}
+
 static VALUE sample_variance(VALUE self) {
-  int size = RARRAY_LEN(self);
+  long size = RARRAY_LEN(self);
   VALUE *array = RARRAY_PTR(self);
 
+  if (size < 2) raise_not_enough_elements();
+
   return rb_float_new(compute_sample_variance(array, size));
 }
 
 static VALUE population_variance(VALUE self) {
-  int size = RARRAY_LEN(self);
+  long size = RARRAY_LEN(self);
   VALUE *array = RARRAY_PTR(self);
 
+  if (size < 2) raise_not_enough_elements();
+
   return rb_float_new(compute_population_variance(array, size));
 }
 
 static VALUE stdev(VALUE self) {
-  int size = RARRAY_LEN(self);
+  long size = RARRAY_LEN(self);
   VALUE *array = RARRAY_PTR(self);
 
+  if (size < 2) raise_not_enough_elements();
+
   return rb_float_new(sqrt(compute_sample_variance(array, size)));
 }
 
 static VALUE stdevp(VALUE self) {
-  int size = RARRAY_LEN(self);
+  long size = RARRAY_LEN(self);
   VALUE *array = RARRAY_PTR(self);
 
+  if (size < 2) raise_not_enough_elements();
+
   return rb_float_new(sqrt(compute_population_variance(array, size)));
 }
 

data/lib/standard_deviation/version.rb

@@ -1,3 +1,3 @@
 module StandardDeviation
-  VERSION = "1.0.0"
+  VERSION = "1.0.1"
 end

data/spec/spec_helper.rb

@@ -1,2 +1,8 @@
 require "standard_deviation"
 require "bigdecimal"
+
+RSpec::Matchers.define :be_close_to do |expected|
+  match do |actual|
+    BigDecimal.new(actual.to_s).round(10) == BigDecimal.new(expected.to_s).round(10)
+  end
+end

data/spec/standard_deviation/standard_deviation_spec.rb

@@ -1,79 +1,103 @@
 require "spec_helper"
 
 describe Array do
-  describe "#stdev" do
-    subject { values.stdev }
-
-    context "with integer values" do
-      let(:values) { [1, 2, 6, 3, -4, 23] }
-      it { should == 9.32559202767667 }
+  shared_examples_for "a serie calculation" do
+    context "when called on a empty array" do
+      let(:values) { [] }
+      it { lambda { subject }.should raise_exception ZeroDivisionError, "not enough elements" }
     end
 
-    context "with float values" do
-      let(:values) { [1.0, 2.0, 6.0, 3.0, -4.0, 23.0] }
-      it { should == 9.32559202767667 }
+    context "when called on a array with only one element" do
+      let(:values) { [1] }
+      it { lambda { subject }.should raise_exception ZeroDivisionError, "not enough elements" }
     end
+  end
 
-    context "with bigdecimal values" do
-      let(:values) { [BigDecimal("1.0"), BigDecimal("2.0"), BigDecimal("6.0"), BigDecimal("3.0"), BigDecimal("-4.0"), BigDecimal("23.0")] }
-      it { should == 9.32559202767667 }
+  %w(stdev standard_deviation).each do |method|
+    describe "##{method}" do
+      subject { values.send method }
+
+      it_should_behave_like "a serie calculation"
+
+      context "with integer values" do
+        let(:values) { [1, 2, 6, 3, -4, 23] }
+        it { should be_close_to 9.32559202767667 }
+      end
+
+      context "with float values" do
+        let(:values) { [1.0, 2.0, 6.0, 3.0, -4.0, 23.0] }
+        it { should be_close_to 9.32559202767667 }
+      end
+
+      context "with bigdecimal values" do
+        let(:values) { [BigDecimal("1.0"), BigDecimal("2.0"), BigDecimal("6.0"), BigDecimal("3.0"), BigDecimal("-4.0"), BigDecimal("23.0")] }
+        it { should be_close_to 9.32559202767667 }
+      end
     end
   end
 
   describe "#stdevp" do
     subject { values.stdevp }
 
+    it_should_behave_like "a serie calculation"
+
     context "with integer values" do
       let(:values) { [1, 2, 6, 3, -4, 23] }
-      it { should == 8.513061859414755 }
+      it { should be_close_to 8.513061859414755 }
     end
 
     context "with float values" do
       let(:values) { [1.0, 2.0, 6.0, 3.0, -4.0, 23.0] }
-      it { should == 8.513061859414755 }
+      it { should be_close_to 8.513061859414755 }
     end
 
     context "with bigdecimal values" do
       let(:values) { [BigDecimal("1.0"), BigDecimal("2.0"), BigDecimal("6.0"), BigDecimal("3.0"), BigDecimal("-4.0"), BigDecimal("23.0")] }
-      it { should == 8.513061859414755 }
+      it { should be_close_to 8.513061859414755 }
     end
   end
 
-  describe "#sample_variance" do
-    subject { values.sample_variance }
+  %w(variance sample_variance).each do |method|
+    describe "##{method}" do
+      subject { values.send method }
 
-    context "with integer values" do
-      let(:values) { [1, 2, 6, 3, -4, 23] }
-      it { should == 86.96666666666665 }
-    end
+      it_should_behave_like "a serie calculation"
 
-    context "with float values" do
-      let(:values) { [1.0, 2.0, 6.0, 3.0, -4.0, 23.0] }
-      it { should == 86.96666666666665 }
-    end
+      context "with integer values" do
+        let(:values) { [1, 2, 6, 3, -4, 23] }
+        it { should be_close_to 86.96666666666665 }
+      end
 
-    context "with bigdecimal values" do
-      let(:values) { [BigDecimal("1.0"), BigDecimal("2.0"), BigDecimal("6.0"), BigDecimal("3.0"), BigDecimal("-4.0"), BigDecimal("23.0")] }
-      it { should == 86.96666666666665 }
+      context "with float values" do
+        let(:values) { [1.0, 2.0, 6.0, 3.0, -4.0, 23.0] }
+        it { should be_close_to 86.96666666666665 }
+      end
+
+      context "with bigdecimal values" do
+        let(:values) { [BigDecimal("1.0"), BigDecimal("2.0"), BigDecimal("6.0"), BigDecimal("3.0"), BigDecimal("-4.0"), BigDecimal("23.0")] }
+        it { should be_close_to 86.96666666666665 }
+      end
     end
   end
 
   describe "#population_variance" do
     subject { values.population_variance }
 
+    it_should_behave_like "a serie calculation"
+
     context "with integer values" do
       let(:values) { [1, 2, 6, 3, -4, 23] }
-      it { should == 72.47222222222221 }
+      it { should be_close_to 72.47222222222221 }
     end
 
     context "with float values" do
       let(:values) { [1.0, 2.0, 6.0, 3.0, -4.0, 23.0] }
-      it { should == 72.47222222222221 }
+      it { should be_close_to 72.47222222222221 }
     end
 
     context "with bigdecimal values" do
       let(:values) { [BigDecimal("1.0"), BigDecimal("2.0"), BigDecimal("6.0"), BigDecimal("3.0"), BigDecimal("-4.0"), BigDecimal("23.0")] }
-      it { should == 72.47222222222221 }
+      it { should be_close_to 72.47222222222221 }
     end
   end
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: standard_deviation
 version: !ruby/object:Gem::Version
-  version: 1.0.0
+  version: 1.0.1
   prerelease: 
 platform: ruby
 authors:
@@ -9,11 +9,11 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2012-04-13 00:00:00.000000000Z
+date: 2012-04-14 00:00:00.000000000Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rake-compiler
-  requirement: &2161598240 !ruby/object:Gem::Requirement
+  requirement: &2156134040 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ! '>='
@@ -21,10 +21,10 @@ dependencies:
         version: '0'
   type: :development
   prerelease: false
-  version_requirements: *2161598240
+  version_requirements: *2156134040
 - !ruby/object:Gem::Dependency
   name: rspec
-  requirement: &2161597660 !ruby/object:Gem::Requirement
+  requirement: &2156133440 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ! '>='
@@ -32,7 +32,7 @@ dependencies:
         version: '0'
   type: :development
   prerelease: false
-  version_requirements: *2161597660
+  version_requirements: *2156133440
 description: ! "An implementation of the standard deviation calculation in C,\n                         with
   much better performance (50x-100x) than using pure ruby."
 email:
@@ -43,10 +43,14 @@ extensions:
 extra_rdoc_files: []
 files:
 - .gitignore
+- .travis.yml
 - Gemfile
 - LICENSE
 - README.md
 - Rakefile
+- benchmark/bigdecimal.rb
+- benchmark/ruby_version.rb
+- benchmark/types.rb
 - ext/standard_deviation/extconf.rb
 - ext/standard_deviation/standard_deviation.c
 - lib/standard_deviation.rb
@@ -69,7 +73,7 @@ required_ruby_version: !ruby/object:Gem::Requirement
       version: '0'
       segments:
       - 0
-      hash: 2357727006440476187
+      hash: -569388018503389721
 required_rubygems_version: !ruby/object:Gem::Requirement
   none: false
   requirements:
@@ -78,7 +82,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
       segments:
       - 0
-      hash: 2357727006440476187
+      hash: -569388018503389721
 requirements: []
 rubyforge_project: 
 rubygems_version: 1.8.10