distribution 0.6.0 → 0.8.0

data/lib/distribution/t/statistics2.rb

@@ -3,26 +3,26 @@ module Distribution
   module T
     module Statistics2_
       class << self
-      # Return the P-value of the corresponding integral with 
-      # k degrees of freedom
-      def p_value(pr,k)
-        Statistics2.ptdist(k, pr)
-      end
-      
-       
-      # There are some problem on i686 with t on statistics2
-      if true or !RbConfig::CONFIG['arch']=~/i686/
-        # T cumulative distribution function (cdf).
-        # 
-        # Returns the integral of t-distribution 
-        # with n degrees of freedom over (-Infty, x].
-        #
-        def cdf(x,k)
-          Statistics2.tdist(k,x)
+        # There are some problem on i686 with t on statistics2
+        if true || !RbConfig::CONFIG['arch'] =~ /i686/
+          # T cumulative distribution function (cdf).
+          #
+          # Returns the integral of t-distribution
+          # with n degrees of freedom over (-Infty, x].
+          #
+          def cdf(x, k)
+            Statistics2.tdist(k, x)
+          end
+
+          # Return the P-value of the corresponding integral with
+          # k degrees of freedom
+          def quantile(pr, k)
+            Statistics2.ptdist(k, pr)
+          end
+
+          alias_method :p_value, :quantile
         end
       end
-      
-      end
     end
   end
-end
+end

data/lib/distribution/uniform.rb

@@ -0,0 +1,26 @@
+require 'distribution/uniform/ruby'
+require 'distribution/uniform/gsl'
+#require 'distribution/uniform/java'
+
+
+module Distribution
+  # Expresses the uniformly spread probability over a finite interval
+  module Uniform
+    SHORTHAND='unif'
+    extend Distributable
+    create_distribution_methods
+
+    ##
+    # :singleton-method: pdf(x, lower, upper)
+    # Returns the uniform PDF
+
+    ##
+    # :singleton-method: cdf(x, lower, upper)
+    # Returns the uniform CDF
+    
+    ##
+    # :singleton-method: quantile(qn, lower, upper)
+    # Returns the uniform inverse CDF or P-value
+
+  end
+end

data/lib/distribution/uniform/gsl.rb

@@ -0,0 +1,36 @@
+module Distribution
+  module Uniform
+    module GSL_
+      class << self
+        # Returns a lambda to call for uniformly distributed random numbers
+        # returns a double precision float in [0, 1]
+        def rng(lower = 0, upper = 1, seed = nil)
+          seed = Random.new_seed.modulo 100000007 if seed.nil?
+          rng = GSL::Rng.alloc(GSL::Rng::MT19937, seed)
+          
+          -> { lower + (upper - lower) * rng.uniform }
+        end
+        
+        # :nodoc:
+        def pdf(x, lower = 0, upper = 1)
+          # rb-gsl/blob/master/ext/gsl_native/randist.c#L1732
+          GSL::Ran.flat_pdf(x, lower, upper)
+        end
+        
+        # :nodoc:
+        def cdf(x, lower = 0, upper = 1)
+          # rb-gsl/blob/master/ext/gsl_native/cdf.c#L644
+          GSL::Cdf.flat_P(x, lower, upper)
+        end
+        
+        # :nodoc:
+        def quantile(qn, lower, upper)
+          # rb-gsl/blob/master/ext/gsl_native/cdf.c#L646
+          GSL::Cdf.flat_Pinv(qn, lower, upper)
+        end
+        
+        alias_method :p_value, :quantile
+      end
+    end
+  end
+end

data/lib/distribution/uniform/ruby.rb

@@ -0,0 +1,91 @@
+module Distribution
+  module Uniform
+    module Ruby_
+      # Module contain pure ruby implementation of the
+      # uniform distribution (rng, pdf, cdf and quantile functions)
+      class << self
+        # Returns a lambda that emits a uniformly distributed
+        # sequence of random numbers between the defined limits
+        #
+        # == Arguments
+        #   * +lower+ - Lower limit of the distribution
+        #   * +upper+ - Upper limit of the distribution
+        #   * +seed+  - Seed to set the initial state, randomized if ommited
+        #
+        def rng(lower = 0, upper = 1, seed = nil)
+          seed = Random.new_seed if seed.nil?
+          prng = Random.new(seed)
+          -> { prng.rand * (upper - lower) + lower }
+        end
+
+        # Uniform probability density function on [a, b]
+        #
+        # == Arguments
+        # If you are referring the wiki page for this continuous distribution
+        # the arguments can be translated as follows
+        #   * +x+ - same as continuous random variable
+        #   * +lower+ - lower limit or a, must be a real number
+        #   * +upper+ - upper limit or b, must be a real number
+        #
+        # == Reference
+        #   * https://en.wikipedia.org/wiki/Uniform_distribution_(continuous)
+        #
+        # The implementation has been adopted from GSL-1.9 gsl/randist/flat.c
+        #
+        def pdf(x, lower = 0, upper = 1)
+          upper, lower = lower, upper if lower > upper
+          return 1 / (upper - lower) if (lower..upper).member? x
+          0
+        end
+
+        # The uniform cumulative density function (CDF)
+        # == Arguments
+        # If you are referring the wiki page for this continuous distribution
+        # the arguments can be translated as follows
+        #   * +x+ - same as continuous random variable
+        #   * +lower+ - lower limit or a, must be a real number
+        #   * +upper+ - upper limit or b, must be a real number
+        #
+        # == Reference
+        #   * https://en.wikipedia.org/wiki/Uniform_distribution_(continuous)
+        #
+        # The implementation has been adpoted from GSL-1.9 gsl/cdf/flat.c
+        #
+        def cdf(x, lower = 0, upper = 1)
+          if x < lower
+            0
+          elsif x > upper
+            1
+          else
+            (x - lower) / (upper - lower)
+          end
+        end
+
+        # The uniform inverse CDF density function / P-value function
+        # == Arguments
+        # If you are referring the wiki page for this continuous distribution
+        # the arguments can be translated as follows
+        #   * +qn+ - same as integral value
+        #   * +lower+ - lower limit or a, must be a real number
+        #   * +upper+ - upper limit or b, must be a real number
+        #
+        # == Returns
+        #   * nil if the integral value is not in [0, 1]
+        #   * inverse cdf otherwise
+        # == Reference
+        #   * https://en.wikipedia.org/wiki/Uniform_distribution_(continuous)
+        #
+        # The implementation has been adpoted from GSL-1.9 gsl/cdf/flatinv.c
+        #
+        def quantile(qn, lower = 0, upper = 1)
+          fail RangeError, 'cdf value(qn) must be from [0, 1]. '\
+          "Cannot find quantile for qn=#{qn}" if qn > 1 || qn < 0
+
+          qn * upper + (1 - qn) * lower
+        end
+
+        alias p_value quantile
+      end
+    end
+  end
+end

data/lib/distribution/version.rb

@@ -0,0 +1,3 @@
+module Distribution
+  VERSION = '0.8.0'
+end

data/lib/distribution/weibull.rb

@@ -0,0 +1,10 @@
+require 'distribution/weibull/ruby'
+require 'distribution/weibull/gsl'
+
+module Distribution
+  module Weibull
+    SHORTHAND = 'weibull'
+    extend Distributable
+    create_distribution_methods
+  end
+end

data/lib/distribution/weibull/gsl.rb

@@ -0,0 +1,21 @@
+module Distribution
+  module Weibull
+    module GSL_
+      class << self
+        def pdf(x, k, lam)
+          GSL::Ran.weibull_pdf(x, lam, k)
+        end
+
+        def cdf(x, k, lam)
+          GSL::Cdf.weibull_P(x, lam, k)
+        end
+
+        def quantile(y, k, lam)
+          GSL::Cdf.weibull_Pinv(y, lam, k)
+        end
+
+        alias_method :p_value, :quantile
+      end
+    end
+  end
+end

data/lib/distribution/weibull/ruby.rb

@@ -0,0 +1,34 @@
+module Distribution
+  module Weibull
+    module Ruby_
+      class << self
+        def pdf(x, k, lam)
+          if x < 0.0
+            0.0
+          else
+            a = (k.to_f / lam.to_f)
+            b = (x.to_f / lam.to_f)
+            c = (k - 1.0)
+            d = Math.exp(-(x.to_f / lam.to_f)**k)
+            (a * b**c) * d
+          end
+        end
+
+        # Returns the integral of the Weibull distribution from [-Inf to x]
+        def cdf(x, k, lam)
+          return 0.0 if x < 0.0
+          1.0 - Math.exp(-(x.to_f / lam.to_f)**k)
+        end
+
+        # Returns the P-value of weibull
+        def quantile(y, k, lam)
+          return 1.0 if y > 1.0
+          return 0.0 if y < 0.0
+          -lam * (Math.log(1.0 - y))**(1.0 / k)
+        end
+
+        alias_method :p_value, :quantile
+      end
+    end
+  end
+end

data/spec/beta_spec.rb

@@ -1,82 +1,80 @@
-require File.expand_path(File.dirname(__FILE__)+"/spec_helper.rb")
+require File.expand_path(File.dirname(__FILE__) + '/spec_helper.rb')
 include ExampleWithGSL
 describe Distribution::Beta do
-
- shared_examples_for "Beta engine" do
-   it_only_with_gsl "should return correct pdf" do
+  shared_examples_for 'Beta engine' do
+    it_only_with_gsl 'should return correct pdf' do
       if @engine.respond_to? :pdf
         1.upto(101) do |x|
-          a=rand * x
-          b=1 + rand * 5
-          g=GSL::Ran.beta_pdf(x,a,b)
-          @engine.pdf(x,a,b).should be_within(1e-10).of(g)
+          a = rand * x
+          b = 1 + rand * 5
+          g = GSL::Ran.beta_pdf(x, a, b)
+          expect(@engine.pdf(x, a, b)).to be_within(1e-09).of(g)
         end
       else
-        pending("No #{@engine}.pdf")
+        skip("No #{@engine}.pdf")
       end
     end
 
-  it_only_with_gsl "should return correct cdf" do
-    if @engine.respond_to? :cdf
-      # From GSL-1.9.
-      TOL = 1048576.0*Float::EPSILON
-      @engine.cdf(0.0, 1.2, 1.3).should eq(0.0)
-      @engine.cdf(1e-100, 1.2, 1.3).should be_within(TOL).of(1.34434944656489596e-120)
-      @engine.cdf(0.001, 1.2, 1.3).should be_within(TOL).of(3.37630042504535813e-4)
-      @engine.cdf(0.01, 1.2, 1.3).should be_within(TOL).of(5.34317264038929473e-3)
-      @engine.cdf(0.1, 1.2, 1.3).should be_within(TOL).of(8.33997828306748346e-2)
-      @engine.cdf(0.325, 1.2, 1.3).should be_within(TOL).of(3.28698654180583916e-1)
-      @engine.cdf(0.5, 1.2, 1.3).should be_within(TOL).of(5.29781429451299081e-1)
-      @engine.cdf(0.9, 1.2, 1.3).should be_within(TOL).of(9.38529397224430659e-1)
-      @engine.cdf(0.99, 1.2, 1.3).should be_within(TOL).of(9.96886438341254380e-1)
-      @engine.cdf(0.999, 1.2, 1.3).should be_within(TOL).of(9.99843792833067634e-1)
-      @engine.cdf(1.0, 1.2, 1.3).should be_within(TOL).of(1.0)
-    else
-      pending("No #{@engine}.cdf")
+    it_only_with_gsl 'should return correct cdf' do
+      if @engine.respond_to? :cdf
+        # From GSL-1.9.
+        tol = 1_048_576.0 * Float::EPSILON
+        expect(@engine.cdf(0.0, 1.2, 1.3)).to eq(0.0)
+        expect(@engine.cdf(1e-100, 1.2, 1.3)).to be_within(tol).of(1.34434944656489596e-120)
+        expect(@engine.cdf(0.001, 1.2, 1.3)).to be_within(tol).of(3.37630042504535813e-4)
+        expect(@engine.cdf(0.01, 1.2, 1.3)).to be_within(tol).of(5.34317264038929473e-3)
+        expect(@engine.cdf(0.1, 1.2, 1.3)).to be_within(tol).of(8.33997828306748346e-2)
+        expect(@engine.cdf(0.325, 1.2, 1.3)).to be_within(tol).of(3.28698654180583916e-1)
+        expect(@engine.cdf(0.5, 1.2, 1.3)).to be_within(tol).of(5.29781429451299081e-1)
+        expect(@engine.cdf(0.9, 1.2, 1.3)).to be_within(tol).of(9.38529397224430659e-1)
+        expect(@engine.cdf(0.99, 1.2, 1.3)).to be_within(tol).of(9.96886438341254380e-1)
+        expect(@engine.cdf(0.999, 1.2, 1.3)).to be_within(tol).of(9.99843792833067634e-1)
+        expect(@engine.cdf(1.0, 1.2, 1.3)).to be_within(tol).of(1.0)
+      else
+        skip("No #{@engine}.cdf")
+      end
     end
-  end
-  it "should return correct p_value" do
-    if @engine.respond_to? :p_value
-      2.upto(99) do |x|
-        a=rand() * x
-        b=1 + rand() * 5
-        pr=@engine.cdf(x/100.0,a,b)
-        @engine.p_value(pr,a, b).should be_within(1e-10).of(x/100.0)
-       end
-    else
-      pending("No #{@engine}.p_value")
+    it 'should return correct p_value' do
+      if @engine.respond_to? :p_value
+        2.upto(99) do |x|
+          a = rand * x
+          b = 1 + rand * 5
+          pr = @engine.cdf(x / 100.0, a, b)
+          expect(@engine.p_value(pr, a, b)).to be_within(1e-09).of(x / 100.0)
+        end
+      else
+        skip("No #{@engine}.p_value")
+      end
     end
   end
-end
 
-  describe "singleton" do
+  describe 'singleton' do
     before do
-      @engine=Distribution::Beta
+      @engine = Distribution::Beta
     end
-    it_should_behave_like "Beta engine"
+    it_should_behave_like 'Beta engine'
   end
-  
+
   describe Distribution::Beta::Ruby_ do
     before do
-      @engine=Distribution::Beta::Ruby_
+      @engine = Distribution::Beta::Ruby_
     end
-    it_should_behave_like "Beta engine"
+    it_should_behave_like 'Beta engine'
   end
   if Distribution.has_gsl?
     describe Distribution::Beta::GSL_ do
       before do
-        @engine=Distribution::Beta::GSL_
+        @engine = Distribution::Beta::GSL_
       end
-    it_should_behave_like "Beta engine"
+      it_should_behave_like 'Beta engine'
     end
   end
   if Distribution.has_java?
     describe Distribution::Beta::Java_ do
       before do
-        @engine=Distribution::Beta::Java_
+        @engine = Distribution::Beta::Java_
       end
-    it_should_behave_like "Beta engine"
-    end  
+      it_should_behave_like 'Beta engine'
+    end
   end
-  
 end

data/spec/binomial_spec.rb

@@ -1,126 +1,122 @@
-require File.expand_path(File.dirname(__FILE__)+"/spec_helper.rb")
+require File.expand_path(File.dirname(__FILE__) + '/spec_helper.rb')
 include ExampleWithGSL
 describe Distribution::Binomial do
-  
-shared_examples_for "binomial engine" do
-  it "should return correct pdf" do
-    if @engine.respond_to? :pdf
-      [10,100,1000].each do |n|
-        [1.quo(4),1.quo(2),3.quo(4)].each do |pr|
-          [0, 1,n/2,n-1].each do |x| 
-            exp=Math.binomial_coefficient(n,x)*pr**x*(1-pr)**(n-x)
-            obs=@engine.pdf(x,n,pr)
-            obs.should be_within(1e-5).of(exp), "For pdf(#{x},#{n},#{pr}) expected #{exp}, obtained #{obs}"
-            
+  shared_examples_for 'binomial engine' do
+    it 'should return correct pdf' do
+      if @engine.respond_to? :pdf
+        [10, 100, 1000].each do |n|
+          [1.quo(4), 1.quo(2), 3.quo(4)].each do |pr|
+            [0, 1, n / 2, n - 1].each do |x|
+              exp = Math.binomial_coefficient(n, x) * pr**x * (1 - pr)**(n - x)
+              obs = @engine.pdf(x, n, pr)
+              expect(obs).to be_within(1e-5).of(exp), "For pdf(#{x},#{n},#{pr}) expected #{exp}, obtained #{obs}"
+            end
           end
         end
+      else
+        skip("No #{@engine}.pdf")
       end
-    else
-      pending("No #{@engine}.pdf")
     end
-  end
-  it_only_with_gsl "should return correct cdf for n<=100" do
-     if @engine.respond_to? :pdf
-        [10,100].each do |n|
-          [0.25,0.5,0.75].each do |pr|
-            [1,n/2,n-1].each do |x| 
-              exp=GSL::Cdf.binomial_P(x,pr,n)
-              obs=@engine.cdf(x,n,pr)
-              exp.should be_within(1e-5).of(obs), "For cdf(#{x},#{n},#{pr}) expected #{exp}, obtained #{obs}"
+
+    it_only_with_gsl 'should return correct cdf for n<=100' do
+      if @engine.respond_to? :pdf
+        [10, 100].each do |n|
+          [0.25, 0.5, 0.75].each do |pr|
+            [1, n / 2, n - 1].each do |x|
+              exp = GSL::Cdf.binomial_P(x, pr, n)
+              obs = @engine.cdf(x, n, pr)
+              expect(exp).to be_within(1e-5).of(obs), "For cdf(#{x},#{n},#{pr}) expected #{exp}, obtained #{obs}"
             end
           end
         end
       else
-        pending("No #{@engine}.cdf")
+        skip("No #{@engine}.cdf")
       end
+    end
   end
 
-  
-  
-end
-
-  describe "singleton" do
+  describe 'singleton' do
     before do
-      @engine=Distribution::Binomial
+      @engine = Distribution::Binomial
     end
-    it_should_behave_like "binomial engine"
-    
-    
-    it {@engine.should respond_to(:exact_pdf) }
+
+    it_should_behave_like 'binomial engine'
+
+    it { expect(@engine).to respond_to(:exact_pdf) }
+
     it {
-      pending("No exact_p_value")
-      @engine.should respond_to(:exact_p_value) 
+      pending('No exact_p_value')
+      expect(@engine).to respond_to(:exact_p_value)
     }
-    it "exact_cdf should return same values as cdf for n=50" do
-      pr=rand()*0.8+0.1
-      n=rand(10)+10
-      [1,(n/2).to_i,n-1].each do |k|
-       
-        @engine.exact_cdf(k,n,pr).should be_within(1e-10).of(@engine.cdf(k,n,pr))
+
+    it 'exact_cdf should return same values as cdf for n=50' do
+      pr = rand * 0.8 + 0.1
+      n = rand(10) + 10
+      [1, (n / 2).to_i, n - 1].each do |k|
+        expect(@engine.exact_cdf(k, n, pr)).to be_within(1e-10).of(@engine.cdf(k, n, pr))
       end
     end
-    
-    it "exact_pdf should not return a Float if not float is used as parameter" do
-      @engine.exact_pdf(1,1,1).should_not be_a(Float)
-      @engine.exact_pdf(16, 80, 1.quo(2)).should_not be_a(Float)
-    end
 
-    
-    
-    
+    it 'exact_pdf should not return a Float if not float is used as parameter' do
+      expect(@engine.exact_pdf(1, 1, 1)).to_not be_a(Float)
+      expect(@engine.exact_pdf(16, 80, 1.quo(2))).to_not be_a(Float)
+    end
   end
-  
+
   describe Distribution::Binomial::Ruby_ do
     before do
-      @engine=Distribution::Binomial::Ruby_
+      @engine = Distribution::Binomial::Ruby_
     end
-    it_should_behave_like "binomial engine"
-    
-    it "should return correct cdf for n>100" do
-      pending("incomplete beta function is slow. Should be replaced for a faster one")
+    it_should_behave_like 'binomial engine'
+
+    it 'should return correct cdf for n>100' do
+      [500, 1000].each do |n|
+        [0.5, 0.6].each do |pr|
+          [n / 2].each do |x|
+            cdf = @engine.exact_cdf(x, n, pr)
+            p_value = @engine.p_value(cdf, n, pr)
+            msg = "For p_value(#{cdf},#{n},#{pr}) expected #{x}, obtained #{p_value}"
+
+            expect(p_value).to eq(x), msg
+          end
+        end
+      end
     end
-    
-    it "should return correct p_value for n<=100" do
+
+    it 'should return correct p_value for n<=100' do
       pending("Can't calculate with precision x using p")
-    [10,100].each do |n|
-      [0.25,0.5,0.75].each do |pr|
-        [n/2].each do |x| 
-          cdf=@engine.cdf(x,n,pr)
-          p_value=@engine.p_value(cdf,n,pr)
-          
-          p_value.should eq(x), "For p_value(#{cdf},#{n},#{pr}) expected #{x}, obtained #{p_value}"
+
+      [10, 100].each do |n|
+        [0.25, 0.5, 0.75].each do |pr|
+          [n / 2].each do |x|
+            cdf = @engine.cdf(x, n, pr)
+            p_value = @engine.p_value(cdf, n, pr)
+
+            msg = "For p_value(#{cdf},#{n},#{pr}) expected #{x}, obtained #{p_value}"
+            expect(p_value).to eq(x), msg
+          end
         end
       end
     end
-    end
-    
   end
+
   if Distribution.has_gsl?
     describe Distribution::Binomial::GSL_ do
       before do
-        @engine=Distribution::Binomial::GSL_
+        @engine = Distribution::Binomial::GSL_
       end
-    it_should_behave_like "binomial engine"
+
+      it_should_behave_like 'binomial engine'
     end
   end
-  #if Distribution.has_statistics2?
-  #  describe Distribution::Binomial::Statistics2_ do
-  #    
-  #    before do
-  #      @engine=Distribution::Binomial::Statistics2_
-  #    end
-    #it_should_behave_like "binomial engine"
-  #  end  
-  #end
-  
+
   if Distribution.has_java?
     describe Distribution::Binomial::Java_ do
       before do
-        @engine=Distribution::Binomial::Java_
+        @engine = Distribution::Binomial::Java_
       end
-    it_should_behave_like "binomial engine"
-    
-    end  
+
+      it_should_behave_like 'binomial engine'
+    end
   end
-  
 end