erv 0.3.1 → 0.3.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: a94686dfda6162e93eb5b19063ef7fd28842d434
-  data.tar.gz: 22b0835f5343f735f5e2f970ce32acc7dac56206
+  metadata.gz: f73f2bc514e8d23844ca2e1652bd0801f661679a
+  data.tar.gz: a772550f0c889fcbf411038c830add3fa144876c
 SHA512:
-  metadata.gz: 61a34d96497ca307867a72d410d1274562808eba25f5fa19ff4c53533f248537cf17df7a0354c62ae10836e01f03edf3fb6eedd844b005ddd7e1fdb8625a2ff5
-  data.tar.gz: b7294f4b04076fff19998ed58c20ad77eb69ae139a80d1821403eb1d60e61fb9aba460fa281c83fb140065818f20a31dcfe15e3bd2d42af93b5a9c0d331cb982
+  metadata.gz: 90c953b59a635bb02e4ee5e079147804b14a7d54033a0230f6d749bd9c3d67750ac6b3d722dfbb1d4a453c1158d1b51d311c348d0e5a3f67bcf3330715ae7d27
+  data.tar.gz: 0420a2bc62b45cf9453070a57b24dc7b7731de3fac657df3500f7404e5cf78de4d621d3c1043e00d9a6e6c1b8cdfc35fc0be7d7bbc207eb65ac4bb8b52188d97

data/lib/erv/discrete_uniform_distribution.rb

@@ -1,8 +1,3 @@
-if RUBY_PLATFORM == 'java'
-  require 'java'
-  java_import org.apache.commons.math3.distribution.UniformIntegerDistribution
-end
-
 require 'erv/distribution'
 require 'erv/support/try'
 
@@ -10,23 +5,23 @@ require 'erv/support/try'
 module ERV
 
   class DiscreteUniformDistribution < Distribution
+    attr_reader :mean, :variance
+
     def initialize(opts)
       super(opts)
 
       raise ArgumentError unless opts[:max_value]
-      max = opts[:max_value].to_i
-      min = opts[:min_value].try(:to_i) || 0
-
-      if RUBY_PLATFORM == 'java'
-        # create distribution
-        d = UniformIntegerDistribution.new(@rng, min, max)
-        # setup sampling function
-        @func = Proc.new { d.sample }
-      else
-        # setup sampling function
-        @func = Proc.new { min + @rng.uniform_int(max-min) }
-      end
+      @max = opts[:max_value].to_i
+      @min = opts[:min_value].try(:to_i) || 0
+      @mean = (@max + @min) / 2.0
+      # See https://en.wikipedia.org/wiki/Discrete_uniform_distribution
+      @variance = ((@max - @min + 1) ** 2 - 1) / 12.0
     end
+
+    def sample
+      @min + @rng.rand(@max - @min)
+    end
+
   end
 
 end

data/lib/erv/exponential_distribution.rb

@@ -21,7 +21,7 @@ module ERV
       # starting from a random variable X ~ U(0,1), which is provided by the
       # RNG, we can obtain a random variable Y ~ Exp(\lambda), with mean = 1 /
       # \lambda, through the transformation: Y = - (1 / \lambda) ln X. see
-      # [GROESE11], section 4.2.3.
+      # [KROESE11], section 4.2.3.
       - @mean * Math.log(@rng.rand)
     end
   end

data/lib/erv/gamma_distribution.rb

@@ -1,32 +1,65 @@
-if RUBY_PLATFORM == 'java'
-  require 'java'
-  JGammaDistribution = org.apache.commons.math3.distribution.GammaDistribution
-end
-
 require 'erv/distribution'
 
 
 module ERV
-
+  # We refer to the formulation of the Gamma distribution adopted by [KROESE11]:
+  #
+  # f(x) = \frac{\lambda^{\alpha} x^{\alpha - 1} e^{-\lambda x}}{\Gamma(\alpha)}
+  #
+  # with \alpha > 0 being the shape parameter, \lambda > 0 being the scale
+  # parameter, and x > 0.
+  #
+  # (Note that, unlike [KROESE11] Wikipedia refers to the \beta parameter as the "rate".)
   class GammaDistribution < Distribution
+    attr_accessor :mean, :variance
+
     def initialize(opts)
       super(opts)
 
-      raise ArgumentError unless opts[:rate] and opts[:shape]
-      scale = 1 / opts[:rate].to_f
-      shape = opts[:shape].to_f
-
-      if RUBY_PLATFORM == 'java'
-        # create distribution
-        d = JGammaDistribution.new(@rng, shape, scale,
-                JGammaDistribution::DEFAULT_INVERSE_ABSOLUTE_ACCURACY)
-        # setup sampling function
-        @func = Proc.new { d.sample }
-      else
-        # setup sampling function
-        @func = Proc.new { @rng.gamma(shape, scale) }
-      end
+      raise ArgumentError unless opts[:scale] and opts[:shape]
+      @scale = opts[:scale].to_f
+      @shape = opts[:shape].to_f
+
+      raise ArgumentError, "scale parameter must be greater than zero!" unless @scale > 0.0
+      raise ArgumentError, "shape parameter must be greater than zero!" unless @shape > 0.0
+
+      @mean = @shape / @scale
+      @variance = @shape / (@scale ** 2)
     end
+
+    # We use Marsaglia and Tsang's sampling algorithm
+    #
+    # For more details, see [KROESE11], section 4.2.6, algorithm 4.33 and 
+    # http://www.hongliangjie.com/2012/12/19/how-to-generate-gamma-random-variables/
+    def sample
+      gamrand(@shape, @scale)
+    end
+
+    private
+
+      def gamrand(shape, scale)
+        if shape >= 1.0
+          d = shape - 1.0 / 3
+          c = 1.0 / Math::sqrt(9 * d)
+          ok = false
+          until ok do
+            # Use box-muller algorithm (see [KROESE11], section 4.2.11, algorithm
+            # 4.47) to obtain z ~ N(0,1).
+            u_1 = @rng.rand
+            u_2 = @rng.rand
+            z = Math::sqrt(-2.0 * Math::log(u_1)) * Math::cos(2.0 * Math::PI * u_2)
+            if z > -1.0 / c
+              v = (1.0 + c * z) ** 3
+              u = @rng.rand
+              ok = Math::log(u) <= (0.5 * (z**2) + d - d * v + d * Math::log(v))
+            end
+          end
+          d * v / scale;
+        else # 0 < @shape < 1
+          gamrand(shape + 1.0, scale) * (@rng.rand ** (1 / shape))
+        end
+      end
+
   end
 
 end

data/lib/erv/gaussian_distribution.rb

@@ -13,14 +13,14 @@ module ERV
     end
 
     def sample
-      # use box-muller algorithm (see [GROESE11], section 4.2.11, algorithm
+      # Use Box-Muller algorithm (see [KROESE11], section 4.2.11, algorithm
       # 4.47) to obtain x ~ N(0,1).
       u_1 = @rng.rand
       u_2 = @rng.rand
       x = Math.sqrt(-2.0 * Math.log(u_1)) * Math.cos(2.0 * Math::PI * u_2)
 
-      # use location-scale transformation to obtain a N(\mu, \sigma^2)
-      # distribution. see [GROESE11], section 3.1.2.2.
+      # Use location-scale transformation to obtain a N(\mu, \sigma^2)
+      # distribution. See [KROESE11], section 3.1.2.2.
       @mu + @sigma * x
     end
 

data/lib/erv/general_pareto_distribution.rb

@@ -1,42 +1,43 @@
-if RUBY_PLATFORM == 'java'
-  require 'java'
-  java_import org.apache.commons.math3.distribution.UniformRealDistribution
-end
-
 require 'erv/distribution'
 require 'erv/support/try'
 
 
 module ERV
 
+  # See https://en.wikipedia.org/wiki/Generalized_Pareto_distribution
   class GpdDistribution < Distribution
+    attr_accessor :mean, :variance
+
     def initialize(opts)
       super(opts)
 
       raise ArgumentError unless opts[:scale] and opts[:shape]
-      scale    = opts[:scale].to_f
-      shape    = opts[:shape].to_f
-      location = opts[:location].try(:to_f) || 0.0
-
-      if RUBY_PLATFORM == 'java'
-        # create uniform distribution
-        d = UniformRealDistribution.new(@rng, 0.0, 1.0,
-                UniformRealDistribution::DEFAULT_INVERSE_ABSOLUTE_ACCURACY)
-        # setup sampling function
-        @func = Proc.new {
-          # this algorithm was taken from wikipedia
-          u = 1.0 - d.sample
-          location + (scale * ((u ** (-shape)) - 1.0) / shape)
-        }
+      @scale    = opts[:scale].to_f
+      @shape    = opts[:shape].to_f
+      @location = opts[:location].try(:to_f) || 0.0
+
+      @mean = if @shape < 1.0
+        @location + @scale / (1.0 - @shape)
+      else
+        Infinity
+      end
+
+      @variance = if @shape < 0.5
+        (@scale ** 2.0) / (((1.0 - @shape) ** 2) * (1.0 - 2 * @shape))
+      else
+        Infinity
+      end
+    end
+
+    def sample
+      u = 1.0 - @rng.rand
+      if @shape == 0.0
+        @location - @scale * Math::log(u)
       else
-        # setup sampling function
-        @func = Proc.new {
-          # this algorithm was taken from wikipedia
-          u = 1.0 - @rng.uniform
-          location + (scale * ((u ** (-shape)) - 1.0) / shape)
-        }
+        @location + (@scale * ((u ** (- @shape)) - 1.0) / @shape)
       end
     end
+
   end
 
 end

data/lib/erv/geometric_distribution.rb

@@ -1,32 +1,33 @@
-if RUBY_PLATFORM == 'java'
-  require 'java'
-  JGeometricDistribution = org.apache.commons.math3.distribution.GeometricDistribution
-end
+require 'erv/distribution'
 
 
 module ERV
 
+  # We adopt the following version of the geometric distribution:
+  #
+  #   Pr(X = k) = (1 - p) ^ {k-1} * p
+  #
+  # See: https://en.wikipedia.org/wiki/Geometric_distribution
   class GeometricDistribution < Distribution
+    attr_accessor :mean, :variance
+
     def initialize(opts)
       super(opts)
 
       raise ArgumentError unless opts[:probability_of_success]
-      p = opts[:probability_of_success].to_f
-
-      if RUBY_PLATFORM == 'java'
-        # create distribution
-        d = JGeometricDistribution.new(@rng, p)
-        # setup sampling function
-        @func = Proc.new { d.sample }
-      else
-        # setup sampling function
-        #
-        # WARNING: I HAVEN'T TRIED THIS CODE!!!
-        # Note that GSL implements the shifted version of the geometric
-        # distribution, so we might need to change the result (removing 1?)
-        @func = Proc.new { @rng.geometric(p) }
-      end
+      @p = opts[:probability_of_success].to_f
+
+      @mean = 1.0 / @p
+      @variance = (1.0 - @p) / (@p ** 2)
+
+      @ln_1_minus_p = Math::log(1 - @p)
     end
+
+    def sample
+      u = @rng.rand
+      (Math::log(u) / @ln_1_minus_p).ceil
+    end
+
   end
 
 end

data/lib/erv/uniform_distribution.rb

@@ -17,7 +17,7 @@ module ERV
     def sample
       # starting from a random variable X ~ U(0,1), which is provided by the
       # RNG, we can obtain a random variable Y ~ U(a,b) through location-scale
-      # transformation: Y = a + (b-a) X. see [GROESE11], section 3.1.2.2.
+      # transformation: Y = a + (b-a) X. see [KROESE11], section 3.1.2.2.
       @min + @range * @rng.rand
     end
   end

data/lib/erv/version.rb

@@ -1,3 +1,3 @@
 module ERV
-  VERSION = '0.3.1'
+  VERSION = '0.3.2'
 end

data/test/erv/discrete_uniform_distribution_test.rb

@@ -0,0 +1,81 @@
+require 'test_helper'
+
+require 'erv/discrete_uniform_distribution'
+
+describe ERV::DiscreteUniformDistribution do
+
+  NUM_SAMPLES = 10000
+
+  it 'should require at least a maximum parameter' do
+    lambda do
+      ERV::DiscreteUniformDistribution.new()
+    end.must_raise ArgumentError
+  end
+
+
+  context 'a (default) 1-parameter distribution' do
+
+    let :zero_to_sixty do
+      ERV::DiscreteUniformDistribution.new(max_value: 60)
+    end
+
+    context 'sampling' do
+
+      it 'should allow sampling' do
+        zero_to_sixty.sample
+      end
+
+    end
+
+    context 'moments' do
+      let :samples do
+        0.upto(NUM_SAMPLES).collect { zero_to_sixty.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 zero_to_sixty.mean, 0.05
+      end
+
+      it 'should have the expected variance' do
+        sample_variance = samples.inject(0.0) {|s,x| s += (x - zero_to_sixty.mean) ** 2 } / NUM_SAMPLES.to_f
+        sample_variance.must_be_within_epsilon zero_to_sixty.variance, 0.05
+      end
+
+    end
+  end
+
+  context 'a 2-parameter distribution' do
+
+    let :ten_to_ninety do
+      ERV::DiscreteUniformDistribution.new(min_value: 10, max_value: 90)
+    end
+
+    context 'sampling' do
+
+      it 'should allow sampling' do
+        ten_to_ninety.sample
+      end
+
+    end
+
+    context 'moments' do
+
+      let :samples do
+        0.upto(NUM_SAMPLES).collect { ten_to_ninety.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 ten_to_ninety.mean, 0.05
+      end
+
+      it 'should have the expected variance' do
+        sample_variance = samples.inject(0.0) {|s,x| s += (x - ten_to_ninety.mean) ** 2 } / NUM_SAMPLES.to_f
+        sample_variance.must_be_within_epsilon ten_to_ninety.variance, 0.05
+      end
+
+    end
+  end
+
+end

data/test/erv/gamma_distribution_test.rb

@@ -0,0 +1,47 @@
+require 'test_helper'
+
+require 'erv/gamma_distribution'
+
+describe ERV::GammaDistribution do
+
+  NUM_SAMPLES = 20000
+
+  it 'should require the scale and shape parameters' do
+    lambda do
+      ERV::GammaDistribution.new()
+    end.must_raise 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
+
+      it 'should allow sampling' do
+        gsgtone.sample
+      end
+
+    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
+  end
+
+end

data/test/erv/general_pareto_distribution_test.rb

@@ -0,0 +1,82 @@
+require 'test_helper'
+
+require 'erv/general_pareto_distribution'
+
+describe ERV::GpdDistribution do
+
+  NUM_SAMPLES = 50000
+
+  it 'should require scale and shape parameters' do
+    lambda do
+      ERV::GpdDistribution.new()
+    end.must_raise ArgumentError
+  end
+
+
+  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
+
+      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
+  end
+
+
+  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
+
+    end
+  end
+end

data/test/erv/geometric_distribution_test.rb

@@ -0,0 +1,44 @@
+require 'test_helper'
+
+require 'erv/geometric_distribution'
+
+describe ERV::GeometricDistribution do
+
+  NUM_SAMPLES = 10000
+
+  it 'should require at least a probability of success parameter' do
+    lambda do
+      ERV::GeometricDistribution.new()
+    end.must_raise ArgumentError
+  end
+
+  let :gd do
+    ERV::GeometricDistribution.new(probability_of_success: 0.5)
+  end
+
+  context 'sampling' do
+
+    it 'should allow sampling' do
+      gd.sample
+    end
+
+  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

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: erv
 version: !ruby/object:Gem::Version
-  version: 0.3.1
+  version: 0.3.2
 platform: ruby
 authors:
 - Mauro Tortonesi
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2017-02-01 00:00:00.000000000 Z
+date: 2017-06-26 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -80,7 +80,7 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: 0.0.3
-description: erv-0.3.1
+description: erv-0.3.2
 email:
 - mauro.tortonesi@unife.it
 executables: []
@@ -108,7 +108,11 @@ files:
 - lib/erv/uniform_distribution.rb
 - lib/erv/version.rb
 - test/erv/constant_distribution_test.rb
+- test/erv/discrete_uniform_distribution_test.rb
 - test/erv/distribution_test.rb
+- test/erv/gamma_distribution_test.rb
+- test/erv/general_pareto_distribution_test.rb
+- test/erv/geometric_distribution_test.rb
 - test/erv/mixture_distribution_test.rb
 - test/erv/random_variable_test.rb
 - test/test_helper.rb
@@ -132,13 +136,17 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.6.8
+rubygems_version: 2.6.11
 signing_key: 
 specification_version: 4
 summary: Easy/elegant Ruby library providing support for random variable generation
 test_files:
 - test/erv/constant_distribution_test.rb
+- test/erv/discrete_uniform_distribution_test.rb
 - test/erv/distribution_test.rb
+- test/erv/gamma_distribution_test.rb
+- test/erv/general_pareto_distribution_test.rb
+- test/erv/geometric_distribution_test.rb
 - test/erv/mixture_distribution_test.rb
 - test/erv/random_variable_test.rb
 - test/test_helper.rb