erv 0.3.5 → 0.4.0

data/test/erv/exponential_distribution_test.rb

@@ -1,44 +1,18 @@
-require 'test_helper'
-
-require 'erv/exponential_distribution'
+require 'erv/distribution_behaviour'
 
 describe ERV::ExponentialDistribution do
-
-  let (:num_samples) { 10000 }
-
   it 'should require the rate parameter' do
-    lambda do
-      ERV::ExponentialDistribution.new()
-    end.must_raise ArgumentError
-  end
-
-  let :ed do
-    ERV::ExponentialDistribution.new(rate: 20.0)
+    expect{ ERV::ExponentialDistribution.new() }.to raise_exception(ArgumentError)
   end
 
-  context 'sampling' do
-
-    it 'should allow sampling' do
-      ed.sample
-    end
-
-  end
-
-  context 'moments' do
-    let :samples do
-      0.upto(num_samples).collect { ed.sample }
-    end
-
-    it 'should have the expected mean' do
-      sample_mean = samples.inject(0.0) {|s,x| s += x } / num_samples.to_f
-      sample_mean.must_be_within_epsilon ed.mean, 0.05
-    end
+  with 'sampling' do
+    let(:distribution) { ERV::ExponentialDistribution.new(rate: 20.0) }
 
-    it 'should have the expected variance' do
-      sample_variance = samples.inject(0.0) {|s,x| s += (x - ed.mean) ** 2 } / num_samples.to_f
-      sample_variance.must_be_within_epsilon ed.variance, 0.05
-    end
+    let(:num_samples) { 200_000 }
+    let(:samples) { num_samples.times.map { distribution.sample } }
+    let(:epsilon) { 1E-2 }
 
+    include ERV::DistributionBehavior
   end
 
 end

data/test/erv/gamma_distribution_test.rb

@@ -1,47 +1,17 @@
-require 'test_helper'
-
-require 'erv/gamma_distribution'
+require 'erv/distribution_behaviour'
 
 describe ERV::GammaDistribution do
-
-  let (:num_samples) { 10000 }
-
   it 'should require the scale and shape parameters' do
-    lambda do
-      ERV::GammaDistribution.new()
-    end.must_raise ArgumentError
+    expect{ ERV::GammaDistribution.new }.to raise_exception(ArgumentError)
   end
 
-  context 'with a shape greater than one' do
-
-    let :gsgtone do
-      ERV::GammaDistribution.new(shape: 2.0, scale: 0.5)
-    end
-
-    context 'sampling' do
+  with 'sampling' do
+    let(:distribution) { ERV::GammaDistribution.new(shape: 2.0, scale: 0.5) }
 
-      it 'should allow sampling' do
-        gsgtone.sample
-      end
+    let(:num_samples) { 200_000 }
+    let(:samples) { num_samples.times.map { distribution.sample } }
+    let(:epsilon) { 1E-2 }
 
-    end
-
-    context 'moments' do
-      let :samples do
-        0.upto(num_samples).collect { gsgtone.sample }
-      end
-
-      it 'should have the expected mean' do
-        sample_mean = samples.inject(0.0) {|s,x| s += x } / num_samples.to_f
-        sample_mean.must_be_within_epsilon gsgtone.mean, 0.05
-      end
-
-      it 'should have the expected variance' do
-        sample_variance = samples.inject(0.0) {|s,x| s += (x - gsgtone.mean) ** 2 } / num_samples.to_f
-        sample_variance.must_be_within_epsilon gsgtone.variance, 0.05
-      end
-
-    end
+    include ERV::DistributionBehavior
   end
-
 end

data/test/erv/gaussian_distribution_test.rb

@@ -1,44 +1,17 @@
-require 'test_helper'
-
-require 'erv/gaussian_distribution'
+require 'erv/distribution_behaviour'
 
 describe ERV::GaussianDistribution do
-
-  let (:num_samples) { 10000 }
-
   it 'should require the scale and shape parameters' do
-    lambda do
-      ERV::GaussianDistribution.new()
-    end.must_raise ArgumentError
+    expect{ ERV::GaussianDistribution.new }.to raise_exception(ArgumentError)
   end
 
-  let :gd do
-    ERV::GaussianDistribution.new(mean: 20.0, sd: 0.5)
-  end
-
-  context 'sampling' do
+  with 'sampling' do
+    let(:distribution) { ERV::GaussianDistribution.new(mean: 20.0, sd: 0.5) }
 
-    it 'should allow sampling' do
-      gd.sample
-    end
+    let(:num_samples) { 200_000 }
+    let(:samples) { num_samples.times.map { distribution.sample } }
+    let(:epsilon) { 5E-3 }
 
+    include ERV::DistributionBehavior
   end
-
-  context 'moments' do
-    let :samples do
-      0.upto(num_samples).collect { gd.sample }
-    end
-
-    it 'should have the expected mean' do
-      sample_mean = samples.inject(0.0) {|s,x| s += x } / num_samples.to_f
-      sample_mean.must_be_within_epsilon gd.mean, 0.05
-    end
-
-    it 'should have the expected variance' do
-      sample_variance = samples.inject(0.0) {|s,x| s += (x - gd.mean) ** 2 } / num_samples.to_f
-      sample_variance.must_be_within_epsilon gd.variance, 0.05
-    end
-
-  end
-
 end

data/test/erv/generalized_pareto_distribution_test.rb

@@ -1,82 +1,33 @@
-require 'test_helper'
-
-require 'erv/generalized_pareto_distribution'
+require 'erv/distribution_behaviour'
 
 describe ERV::GpdDistribution do
-
-  let (:num_samples) { 200000 }
-
-  it 'should require scale and shape parameters' do
-    lambda do
-      ERV::GpdDistribution.new()
-    end.must_raise ArgumentError
+  it 'should require the scale and shape parameters' do
+    expect{ ERV::GpdDistribution.new }.to raise_exception(ArgumentError)
   end
 
+  with 'a (default) 2-parameter distribution' do
+    # Caveat:
+    # 1) if shape >= 0.5, variance is infinite
+    # 2) if shape >= 0.25, the 4th moment is infinite - so the variance of the
+    #    variance is infinite
+    let(:distribution) { ERV::GpdDistribution.new(scale: 1.0, shape: 0.1) }
 
-  context 'a (default) 2-parameter distribution' do
-
-    let :gpd_2params do
-      ERV::GpdDistribution.new(scale: 1.0, shape: 0.3)
-    end
-
-    context 'sampling' do
-
-      it 'should allow sampling' do
-        gpd_2params.sample
-      end
-
-    end
-
-    context 'moments' do
-      let :samples do
-        0.upto(num_samples).collect { gpd_2params.sample }
-      end
-
-      it 'should have the expected mean' do
-        sample_mean = samples.inject(0.0) {|s,x| s += x } / num_samples.to_f
-        sample_mean.must_be_within_epsilon gpd_2params.mean, 0.1
-      end
+    let(:num_samples) { 200_000 }
+    let(:samples) { num_samples.times.map { distribution.sample } }
+    let(:epsilon) { 1E-2 }
 
-      it 'should have the expected variance' do
-        sample_variance = samples.inject(0.0) {|s,x| s += (x - gpd_2params.mean) ** 2 } / num_samples.to_f
-        sample_variance.must_be_within_epsilon gpd_2params.variance, 0.1
-      end
-
-    end
+    include ERV::DistributionBehavior
   end
 
+  with 'a 3-parameter distribution' do
+    let(:distribution) { ERV::GpdDistribution.new(scale: 1.0,
+                                                  shape: 0.1,
+                                                  location: 1.0) }
 
-  context 'a 3-parameter distribution' do
-
-    let :gpd_3params do
-      ERV::GpdDistribution.new(scale: 1.0,
-                               shape: 0.3,
-                               location: 1.0)
-    end
-
-    context 'sampling' do
-
-      it 'should allow sampling' do
-        gpd_3params.sample
-      end
-
-    end
-
-    context 'moments' do
-      let :samples do
-        0.upto(num_samples).collect { gpd_3params.sample }
-      end
-
-      it 'should have the expected mean' do
-        sample_mean = samples.inject(0.0) {|s,x| s += x } / num_samples.to_f
-        sample_mean.must_be_within_epsilon gpd_3params.mean, 0.1
-      end
-
-      it 'should have the expected variance' do
-        sample_variance = samples.inject(0.0) {|s,x| s += (x - gpd_3params.mean) ** 2 } / num_samples.to_f
-        sample_variance.must_be_within_epsilon gpd_3params.variance, 0.1
-      end
+    let(:num_samples) { 200_000 }
+    let(:samples) { num_samples.times.map { distribution.sample } }
+    let(:epsilon) { 1E-2 }
 
-    end
+    include ERV::DistributionBehavior
   end
 end

data/test/erv/geometric_distribution_test.rb

@@ -1,44 +1,17 @@
-require 'test_helper'
-
-require 'erv/geometric_distribution'
+require 'erv/distribution_behaviour'
 
 describe ERV::GeometricDistribution do
-
-  let (:num_samples) { 10000 }
-
   it 'should require at least a probability of success parameter' do
-    lambda do
-      ERV::GeometricDistribution.new()
-    end.must_raise ArgumentError
+    expect{ ERV::GeometricDistribution.new }.to raise_exception(ArgumentError)
   end
 
-  let :gd do
-    ERV::GeometricDistribution.new(probability_of_success: 0.5)
-  end
-
-  context 'sampling' do
+  with 'sampling' do
+    let(:distribution) { ERV::GeometricDistribution.new(probability_of_success: 0.5) }
 
-    it 'should allow sampling' do
-      gd.sample
-    end
+    let(:num_samples) { 200_000 }
+    let(:samples) { num_samples.times.map { distribution.sample } }
+    let(:epsilon) { 5E-3 }
 
+    include ERV::DistributionBehavior
   end
-
-  context 'moments' do
-    let :samples do
-      0.upto(num_samples).collect { gd.sample }
-    end
-
-    it 'should have the expected mean' do
-      sample_mean = samples.inject(0.0) {|s,x| s += x } / num_samples.to_f
-      sample_mean.must_be_within_epsilon gd.mean, 0.05
-    end
-
-    it 'should have the expected variance' do
-      sample_variance = samples.inject(0.0) {|s,x| s += (x - gd.mean) ** 2 } / num_samples.to_f
-      sample_variance.must_be_within_epsilon gd.variance, 0.05
-    end
-
-  end
-
 end

data/test/erv/log_normal_distribution_test.rb

@@ -0,0 +1,17 @@
+require 'erv/distribution_behaviour'
+
+describe ERV::LogNormDistribution do
+  it 'should require the mu and sigma parameters' do
+    expect{ ERV::LogNormDistribution.new }.to raise_exception(ArgumentError)
+  end
+
+  with 'sampling' do
+    let(:distribution) { ERV::LogNormDistribution.new(mu: 0.0, sigma: 0.25) }
+
+    let(:num_samples) { 200_000 }
+    let(:samples) { num_samples.times.map { distribution.sample } }
+    let(:epsilon) { 1E-2 }
+
+    include ERV::DistributionBehavior
+  end
+end

data/test/erv/mixture_distribution_test.rb

@@ -1,123 +1,97 @@
-require 'test_helper'
-
-require 'erv/mixture_distribution'
+require 'erv/distribution_behaviour'
 
 describe ERV::MixtureDistribution do
 
   let (:num_samples) { 10000 }
 
   it 'should require at least two distributions' do
-    lambda do
+    expect{
       ERV::MixtureDistribution.new([ { distribution: :exponential, args: { rate: 1.0 }, weight: 0.5 } ])
-    end.must_raise ArgumentError
+    }.to raise_exception(ArgumentError)
   end
 
-  context 'sampling' do
-
-    let :md do
+  with 'sampling' do
+    let(:distribution) do
       ERV::MixtureDistribution.new([ { distribution: :exponential, args: { rate: 1.0 }, weight: 0.3 },
                                      { distribution: :exponential, args: { rate: 2.0 }, weight: 0.2 },
                                      { distribution: :exponential, args: { rate: 3.0 }, weight: 0.5 } ])
     end
 
     it 'should allow sampling from the mixture' do
-      md.sample
+      expect{ distribution.sample }.not.to raise_exception(ArgumentError).and(! be_nil)
     end
-
   end
 
-  context 'moments' do
-
-    context 'with normalized weights' do
-
-      let :amd do
+  with 'moments' do
+    with 'with normalized weights' do
+      let(:distribution) do
         ERV::MixtureDistribution.new([ { distribution: :gaussian, args: { mean: 1.0, sd: 0.1 }, weight: 0.3 },
                                        { distribution: :gaussian, args: { mean: 2.0, sd: 0.2 }, weight: 0.2 },
                                        { distribution: :gaussian, args: { mean: 3.0, sd: 0.3 }, weight: 0.5 } ])
       end
 
-      let :amd_expected_mean do
+      let(:expected_mean) do
         0.3 * 1.0 +
         0.2 * 2.0 +
         0.5 * 3.0
       end
 
-      let :amd_expected_variance do
-        0.3 * ((1.0 - amd_expected_mean) ** 2 + 0.1 ** 2) +
-        0.2 * ((2.0 - amd_expected_mean) ** 2 + 0.2 ** 2) +
-        0.5 * ((3.0 - amd_expected_mean) ** 2 + 0.3 ** 2)
+      let(:expected_variance) do
+        0.3 * ((1.0 - expected_mean) ** 2 + 0.1 ** 2) +
+        0.2 * ((2.0 - expected_mean) ** 2 + 0.2 ** 2) +
+        0.5 * ((3.0 - expected_mean) ** 2 + 0.3 ** 2)
       end
 
       it 'should correctly calculate the mean of the mixture' do
-        amd.mean.must_equal amd_expected_mean
+        expect(distribution.mean).to be == expected_mean
       end
 
       it 'should correctly calculate the variance of the mixture' do
-        amd.variance.must_equal amd_expected_variance
+        expect(distribution.variance).to be == expected_variance
       end
 
-      let :samples do
-        0.upto(num_samples).collect { amd.sample }
-      end
-
-      it 'mean of a sample set should match the expected mean' do
-        sample_mean = samples.inject(0.0) {|s,x| s += x } / num_samples.to_f
-        sample_mean.must_be_within_epsilon amd.mean, 0.05
-      end
-
-      it 'variance of a sample set should match the expected variance' do
-        sample_variance = samples.inject(0.0) {|s,x| s += (x - amd.mean) ** 2 } / num_samples.to_f
-        sample_variance.must_be_within_epsilon amd.variance, 0.05
-      end
+      let(:num_samples) { 200_000 }
+      let(:samples) { num_samples.times.map { distribution.sample } }
+      let(:epsilon) { 5E-2 }
 
+      include ERV::DistributionBehavior
     end
 
-    context 'with unnormalized weights' do
-
-      let :uwmd do
+    with 'with unnormalized weights' do
+      let(:distribution) do
         ERV::MixtureDistribution.new([ { distribution: :exponential, args: { rate: 1.0 }, weight: 300 },
                                        { distribution: :exponential, args: { rate: 2.0 }, weight: 200 },
                                        { distribution: :exponential, args: { rate: 3.0 }, weight: 500 } ])
       end
 
-      let :uwmd_expected_mean do
+      let(:expected_mean) do
         0.3 * 1/1.0 + 0.2 * 1/2.0 + 0.5 * 1/3.0
       end
 
-      let :uwmd_expected_variance do
-        0.3 * ((1/1.0 - uwmd_expected_mean) ** 2 + (1/1.0) ** 2) +
-        0.2 * ((1/2.0 - uwmd_expected_mean) ** 2 + (1/2.0) ** 2) +
-        0.5 * ((1/3.0 - uwmd_expected_mean) ** 2 + (1/3.0) ** 2)
+      let(:expected_variance) do
+        0.3 * ((1/1.0 - expected_mean) ** 2 + (1/1.0) ** 2) +
+        0.2 * ((1/2.0 - expected_mean) ** 2 + (1/2.0) ** 2) +
+        0.5 * ((1/3.0 - expected_mean) ** 2 + (1/3.0) ** 2)
       end
 
       it 'should correctly calculate the mean of the mixture' do
-        uwmd.mean.must_equal uwmd_expected_mean
+        expect(distribution.mean).to be == expected_mean
       end
 
       it 'should correctly calculate the variance of the mixture' do
-        uwmd.variance.must_equal uwmd_expected_variance
+        expect(distribution.variance).to be == expected_variance
       end
 
-      let :samples do
-        0.upto(num_samples).collect { uwmd.sample }
-      end
-
-      it 'mean of a sample set should match the expected mean' do
-        sample_mean = samples.inject(0.0) {|s,x| s += x } / num_samples.to_f
-        sample_mean.must_be_within_epsilon uwmd.mean, 0.05
-      end
-
-      it 'variance of a sample set should match the expected variance' do
-        sample_variance = samples.inject(0.0) {|s,x| s += (x - uwmd.mean) ** 2 } / num_samples.to_f
-        sample_variance.must_be_within_epsilon uwmd.variance, 0.05
-      end
+      let(:num_samples) { 200_000 }
+      let(:samples) { num_samples.times.map { distribution.sample } }
+      let(:epsilon) { 5E-2 }
 
+      include ERV::DistributionBehavior
     end
-
   end
 
-  context 'mixture of mixtures' do
-    let :momd do
+  with 'mixture of mixtures' do
+    let(:distribution) do
       ERV::MixtureDistribution.new([ { distribution: :mixture,
                                        args: [ { distribution: :exponential, args: { rate: 4.0 }, weight: 300 },
                                                { distribution: :exponential, args: { rate: 5.0 }, weight: 200 },
@@ -132,9 +106,7 @@ describe ERV::MixtureDistribution do
     end
 
     it 'should allow sampling from the mixture' do
-      momd.sample
+      expect{ distribution.sample }.not.to raise_exception(ArgumentError).and(! be_nil)
     end
-
   end
-
 end

data/test/erv/random_variable_test.rb

@@ -1,19 +1,13 @@
-require 'test_helper'
-
-require 'erv/random_variable'
-
 describe ERV::SequentialRandomVariable do
 
   it 'should require the :first_value parameter' do
-    lambda do
-      ERV::SequentialRandomVariable.new
-    end.must_raise ArgumentError
+    expect{ ERV::SequentialRandomVariable.new }.to raise_exception(ArgumentError)
   end
 
   it 'should consider starting value' do
     first = 1.0
     srv = ERV::SequentialRandomVariable.new(first_value: first, distribution: :exponential, args: { rate: 2.0 })
-    srv.next.must_be :>, first
+    expect(srv.next).to (be > first)
   end
 
   it 'should consider previous sample' do
@@ -22,7 +16,7 @@ describe ERV::SequentialRandomVariable do
     previous_sample = srv.next
     10.times do
       new_sample = srv.next
-      new_sample.must_be :>, previous_sample
+      expect(new_sample).to (be > previous_sample)
       previous_sample = new_sample
     end
   end