distribution 0.7.3 → 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

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

data/lib/distribution/weibull.rb

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

data/lib/distribution/weibull/gsl.rb

@@ -1,21 +1,21 @@
 module Distribution
-       module Weibull
-       	      module GSL_
-	      	     class << self
-
-		     	   def pdf(x, k, lam)
-		     	       GSL::Ran.weibull_pdf(x, lam, k)
-		     	   end
-
+  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 cdf(x, k, lam)
+          GSL::Cdf.weibull_P(x, lam, k)
+        end
 
-		     	   def p_value(y, k, lam)
-		     	       GSL::Cdf.weibull_Pinv(y, lam, k)
-		     	   end
-		    end
-	      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

@@ -1,27 +1,34 @@
 module Distribution
-       module Weibull
-       	      module Ruby_
-	      	     class << self
-		     	   def pdf(x, k, lam)
-		     	       return 0.0 if x < 0.0
-			       return ((k.to_f/lam.to_f)*(x.to_f/lam.to_f)**(k-1.0))*Math.exp(-(x.to_f/lam.to_f)**k)
-		     	   end
+  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]
+        # 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
 
-		     	   def cdf(x, k, lam)
-		     	       return 0.0 if x < 0.0
-			       return 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
 
-		     	   # Returns the P-value of weibull
-		     
-			   def p_value(y, k, lam)
-		     	       return 1.0 if y > 1.0
-			       return 0.0 if y < 0.0
-		     	       return -lam*(Math.log(1.0-y))**(1.0/k)
-		     	   end
-		      end
-	      	end
-       end
-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-09).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
         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
-      skip("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-09).of(x/100.0)
-       end
-    else
-      skip("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"
+      it_should_behave_like 'Beta engine'
     end
   end
-
 end