distribution 0.7.2 → 0.7.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 5ad89b4b418c98eadf4c2a4ed5c9cba5b63bb22d
-  data.tar.gz: 52f3687e89e6ba1e76a13f8ff551a664efe21854
+  metadata.gz: 4904710a92ef44ae987119ac6c214ea860735cd9
+  data.tar.gz: 8a6381d47062634afade73cafbcd093603db985b
 SHA512:
-  metadata.gz: 0163e569b86ac34b5beec82d883371482fa39a78c59705fd4236f41567f4fa1785ab7c35cdb08c3e1f9b0a7694d0787e190aad0898ba768185a6a88d72dc58fe
-  data.tar.gz: ad23f9bae7be679a5324b4b37dedabbc8d7702b360a602c4b24df92d210892143c7d8f3b9dcec677dadebddf08d18df2d3d24e2d42dcfe997446973656987e64
+  metadata.gz: 9142471e941e7a2a44ecc727c698fc18bf46da46964e0f49ea2e80ebd829284a1b53284ceaed4135d7ac9ade786e04a4bc155d9e3bb104151925f1d88b6ec9f8
+  data.tar.gz: 2f019d5d7388e7af9c0d7d4e93f02eacdd06ac302bc5d7f72172e8fa6df00fc5c23fbe99a035f87989ad2cb692da523eaa1127338e3f673da84b3e006a0a69b3

data/Gemfile

@@ -1,3 +1,5 @@
 source "https://rubygems.org"
-gem "rb-gsl", :platforms=>[:ruby,:mswin]
+
+gem 'rb-gsl', '~> 1.16'
+
 gemspec

data/History.txt

@@ -1,3 +1,6 @@
+=== 0.7.3 / 2015-05-28
+  * Fixed F::Ruby_.p_value.
+
 === 0.7.2 / 2015-04-03
   * Formatting files according to the community's best practices.
   * Other minor improvements in gemspec, Rakefile, etc.

data/lib/distribution.rb

@@ -39,7 +39,6 @@ require 'distribution/version'
 #    Distribution::Normal.p_value(0.95)
 #    => 1.64485364660836
 module Distribution
-
   SQ2PI = Math.sqrt(2 * Math::PI)
 
   module Shorthand
@@ -150,7 +149,5 @@ module Distribution
   require 'distribution/lognormal'
   require 'distribution/weibull'
 
-  if has_java?
-    init_java
-  end
+  init_java if has_java?
 end

data/lib/distribution/beta.rb

@@ -5,22 +5,21 @@ require 'distribution/beta/java'
 
 module Distribution
   # From Wikipedia:
-  #    In probability theory and statistics, the beta distribution 
-  #    is a family of continuous probability distributions defined 
-  #    on the interval (0, 1) parameterized by two positive shape 
-  #    parameters, typically denoted by alpha and beta. 
+  #    In probability theory and statistics, the beta distribution
+  #    is a family of continuous probability distributions defined
+  #    on the interval (0, 1) parameterized by two positive shape
+  #    parameters, typically denoted by alpha and beta.
   # This module calculate cdf and inverse cdf for Beta Distribution.
   #
   module Beta
     extend Distributable
-    SHORTHAND='beta'
+    SHORTHAND = 'beta'
     create_distribution_methods
 
     ##
     # :singleton-method: pdf(x,a,b)
     # Returns PDF of of Beta distribution with parameters a and b
 
-
     ##
     # :singleton-method: cdf(x,a,b)
     # Returns the integral of Beta distribution with parameters a and b
@@ -28,7 +27,6 @@ module Distribution
     ##
     # :singleton-method: p_value(qn,a,b)
     # Return the quantile of the corresponding integral +qn+
-    # on a beta distribution's cdf with parameters a and b 
-
+    # on a beta distribution's cdf with parameters a and b
   end
 end

data/lib/distribution/beta/gsl.rb

@@ -2,21 +2,21 @@ module Distribution
   module Beta
     module GSL_
       class << self
-        def pdf(x,a,b)
-          GSL::Ran::beta_pdf(x.to_f, a.to_f, b.to_f)
+        def pdf(x, a, b)
+          GSL::Ran.beta_pdf(x.to_f, a.to_f, b.to_f)
         end
         # Return the P-value of the corresponding integral with
         # k degrees of freedom
-        def p_value(pr,a,b)
-          GSL::Cdf::beta_Pinv(pr.to_f, a.to_f, b.to_f)
+        def p_value(pr, a, b)
+          GSL::Cdf.beta_Pinv(pr.to_f, a.to_f, b.to_f)
         end
         # Beta cumulative distribution function (cdf).
         #
         # Returns the integral of Beta distribution
         # with parameters +a+ and +b+ over [0, x]
         #
-        def cdf(x,a,b)
-          GSL::Cdf::beta_P(x.to_f, a.to_f, b.to_f)
+        def cdf(x, a, b)
+          GSL::Cdf.beta_P(x.to_f, a.to_f, b.to_f)
         end
       end
     end

data/lib/distribution/beta/java.rb

@@ -6,4 +6,4 @@ module Distribution
       end
     end
   end
-end
+end

data/lib/distribution/beta/ruby.rb

@@ -3,7 +3,6 @@ module Distribution
   module Beta
     module Ruby_
       class << self
-
         include Math
         # Beta distribution probability density function
         #
@@ -13,38 +12,38 @@ module Distribution
         #
         # == References
         # * http://www.gnu.org/s/gsl/manual/html_node/The-Gamma-Distribution.html
-        def pdf(x,a,b)
+        def pdf(x, a, b)
           return 0 if x < 0 || x > 1
 
-          gab = Math.lgamma(a+b).first
+          gab = Math.lgamma(a + b).first
           ga  = Math.lgamma(a).first
           gb  = Math.lgamma(b).first
 
           if x == 0.0 || x == 1.0
-            Math.exp(gab - ga - gb) * x**(a-1) * (1-x)**(b-1)
+            Math.exp(gab - ga - gb) * x**(a - 1) * (1 - x)**(b - 1)
           else
-            Math.exp(gab - ga - gb + Math.log(x)*(a-1) + Math::Log.log1p(-x)*(b-1))
+            Math.exp(gab - ga - gb + Math.log(x) * (a - 1) + Math::Log.log1p(-x) * (b - 1))
           end
         end
 
         # Gamma cumulative distribution function
         # Translated from GSL-1.9: cdf/beta.c gsl_cdf_beta_P
-        def cdf(x,a,b)
+        def cdf(x, a, b)
           return 0.0 if x <= 0.0
           return 1.0 if x >= 1.0
-          Math::IncompleteBeta.axpy(1.0, 0.0, a,b,x)
+          Math::IncompleteBeta.axpy(1.0, 0.0, a, b, x)
         end
 
         # Inverse of the beta distribution function
-        def p_value(p,a,b, rmin=0, rmax=1)
-          raise "a <= 0" if a <= 0
-          raise "b <= 0" if b <= 0
-          raise "rmin == rmax" if rmin == rmax
-          raise "p <= 0" if p <= 0
-          raise "p > 1" if p > 1
+        def p_value(p, a, b, rmin = 0, rmax = 1)
+          fail 'a <= 0' if a <= 0
+          fail 'b <= 0' if b <= 0
+          fail 'rmin == rmax' if rmin == rmax
+          fail 'p <= 0' if p <= 0
+          fail 'p > 1' if p > 1
 
-          precision=8.88e-016
-          max_iterations=256
+          precision = 8.88e-016
+          max_iterations = 256
 
           ga = 0
           gb = 2
@@ -62,14 +61,13 @@ module Distribution
               ga = guess
             end
 
-            raise 'No value' if i == max_iterations
+            fail 'No value' if i == max_iterations
 
-            i+=1
+            i += 1
           end
 
           rmin + guess * (rmax - rmin)
         end
-
       end
     end
   end

data/lib/distribution/binomial.rb

@@ -2,27 +2,26 @@ require 'distribution/binomial/ruby'
 require 'distribution/binomial/gsl'
 require 'distribution/binomial/java'
 module Distribution
-
   # Calculate statisticals for Binomial Distribution.
   module Binomial
-    SHORTHAND = 'bino'  
-    
+    SHORTHAND = 'bino'
+
     extend Distributable
     create_distribution_methods
-      
+
     ##
     # :singleton-method: pdf(x,k)
-    # Returns the integral of T distribution 
-    # with +k+ degrees of freedom over [0, +x+]    
+    # Returns the integral of T distribution
+    # with +k+ degrees of freedom over [0, +x+]
 
     ##
     # :singleton-method: p_value(qn, k)
-    # Return the P-value of the corresponding integral +qn+ with 
-    # +k+ degrees of freedom    
-    
+    # Return the P-value of the corresponding integral +qn+ with
+    # +k+ degrees of freedom
+
     ##
     # :singleton-method: cdf(x,k)
-    # Returns the integral of T distribution 
-    # with +k+ degrees of freedom over [0, +x+]    
+    # Returns the integral of T distribution
+    # with +k+ degrees of freedom over [0, +x+]
   end
 end

data/lib/distribution/binomial/gsl.rb

@@ -2,13 +2,14 @@ module Distribution
   module Binomial
     module GSL_
       class << self
-        def pdf(k,n,prob)
-          GSL::Ran.binomial_pdf(k,prob,n)
+        def pdf(k, n, prob)
+          GSL::Ran.binomial_pdf(k, prob, n)
         end
-        def cdf(k,n,prob)
-          GSL::Cdf.binomial_P(k,prob,n)
+
+        def cdf(k, n, prob)
+          GSL::Cdf.binomial_P(k, prob, n)
         end
       end
     end
   end
-end
+end

data/lib/distribution/binomial/java.rb

@@ -6,4 +6,4 @@ module Distribution
       end
     end
   end
-end
+end

data/lib/distribution/binomial/ruby.rb

@@ -2,30 +2,32 @@ module Distribution
   module Binomial
     module Ruby_
       class << self
-        def pdf(k,n,pr)
-          raise "k>n" if k>n
-          Math.binomial_coefficient(n,k)*(pr**k)*(1-pr)**(n-k)          
+        def pdf(k, n, pr)
+          fail 'k>n' if k > n
+          Math.binomial_coefficient(n, k) * (pr**k) * (1 - pr)**(n - k)
         end
-        # TODO: Use exact_regularized_beta for 
+        # TODO: Use exact_regularized_beta for
         # small values and regularized_beta for bigger ones.
-        def cdf(k,n,pr)
-          #(0..x.floor).inject(0) {|ac,i| ac+pdf(i,n,pr)}
-          Math.regularized_beta(1-pr,n - k,k+1)
+        def cdf(k, n, pr)
+          # (0..x.floor).inject(0) {|ac,i| ac+pdf(i,n,pr)}
+          Math.regularized_beta(1 - pr, n - k, k + 1)
         end
-        def exact_cdf(k,n,pr)
-          out=(0..k).inject(0) {|ac,i| ac+pdf(i,n,pr)}
-          out=1 if out>1.0
-          return out
+
+        def exact_cdf(k, n, pr)
+          out = (0..k).inject(0) { |ac, i| ac + pdf(i, n, pr) }
+          out = 1 if out > 1.0
+          out
         end
-        def p_value(prob,n,pr)
-          ac=0
+
+        def p_value(prob, n, pr)
+          ac = 0
           (0..n).each do |i|
-            ac+=pdf(i,n,pr)
-            return i if prob<=ac
+            ac += pdf(i, n, pr)
+            return i if prob <= ac
           end
         end
-        
-        alias :exact_pdf :pdf 
+
+        alias_method :exact_pdf, :pdf
       end
     end
   end

data/lib/distribution/chisquare/ruby.rb

@@ -22,32 +22,34 @@ module Distribution
         # Pr([x, \infty)) = y -> x
         def pchi2(n, y)
           if n == 1
-          
-          w = Distribution::Normal.p_value(1 - y/2) # = p1.0-Distribution::Normal.cdf(y/2)
-          w * w
+            w = Distribution::Normal.p_value(1 - y/2) # = p1.0-Distribution::Normal.cdf(y/2)
+            w * w
           elsif n == 2
-          #      v = (1.0 / y - 1.0) / 33.0
-          #      newton_a(y, v) {|x| [q_chi2(n, x), -chi2dens(n, x)] }
-          -2.0 * Math.log(y)
+            #      v = (1.0 / y - 1.0) / 33.0
+            #      newton_a(y, v) {|x| [q_chi2(n, x), -chi2dens(n, x)] }
+            -2.0 * Math.log(y)
           else
-          eps = 1.0e-5
-          v = 0.0
-          s = 10.0
-          loop do
-          v += s
-          if s <= eps then break end
-          if (qe = q_chi2(n, v) - y) == 0.0 then break end
-          if qe < 0.0
-            v -= s
-            s /= 10.0 #/
-          end
+            eps = 1.0e-5
+            v = 0.0
+            s = 10.0
+            loop do
+              v += s
+              if s <= eps then break end
+              if (qe = q_chi2(n, v) - y) == 0.0 then break end
+              if qe < 0.0
+              v -= s
+              s /= 10.0
+            end
           end
+
           v
           end
         end
+
         def p_value(pr,k)
           pchi2(k, 1.0-pr)
         end
+
         def cdf(x,k)
           1.0-q_chi2(k,x)
         end
@@ -55,29 +57,32 @@ module Distribution
         # chi-square distribution ([1])
         # Integral over [x, \infty)
         def q_chi2(df, chi2)
-        chi2 = chi2.to_f
-        if (df & 1) != 0
-        chi = Math.sqrt(chi2)
-        if (df == 1) then return 2 * (1.0-Distribution::Normal.cdf(chi)); end
-        s = t = chi * Math.exp(-0.5 * chi2) / SQ2PI
-        k = 3
-        while k < df
-        t *= chi2 / k;  s += t;
-        k += 2
-        end
-        2 * (1.0-(Distribution::Normal.cdf(chi)) + s)
-        else
-        s = t = Math.exp(-0.5 * chi2)
-        k = 2
-        while k < df
-        t *= chi2 / k;  s += t;
-        k += 2
-        end
-        s
-        end
+          chi2 = chi2.to_f
+          if (df & 1) != 0
+            chi = Math.sqrt(chi2)
+
+            if (df == 1) then return 2 * (1.0-Distribution::Normal.cdf(chi)); end
+            s = t = chi * Math.exp(-0.5 * chi2) / SQ2PI
+            k = 3
+
+            while k < df
+              t *= chi2 / k;  s += t;
+              k += 2
+            end
+
+            2 * (1.0-(Distribution::Normal.cdf(chi)) + s)
+
+          else
+            s = t = Math.exp(-0.5 * chi2)
+            k = 2
+
+            while k < df
+              t *= chi2 / k;  s += t;
+              k += 2
+            end
+            s
+          end
         end
-        
-        
       end
     end
   end

data/lib/distribution/f.rb

@@ -4,26 +4,25 @@ require 'distribution/f/statistics2'
 require 'distribution/f/java'
 module Distribution
   # Calculate cdf and inverse cdf for F Distribution.
-  # 
+  #
   module F
-    SHORTHAND='fdist'  
+    SHORTHAND='fdist'
     extend Distributable
     create_distribution_methods
-    
+
     ##
     # :singleton-method: pdf(x,k1,k2)
-    # Returns the PDF of F distribution 
-    # with +k1+ and +k2+ degrees of freedom over [0, +x+]    
+    # Returns the PDF of F distribution
+    # with +k1+ and +k2+ degrees of freedom over [0, +x+]
 
     ##
     # :singleton-method: p_value(qn, k1, k2)
-    # Return the P-value of the corresponding integral +qn+ with 
-    # +k1+ and +k2+ degrees of freedom    
-    
+    # Return the P-value of the corresponding integral +qn+ with
+    # +k1+ and +k2+ degrees of freedom
+
     ##
     # :singleton-method: cdf(x,k1,k2)
-    # Returns the integral of F distribution 
-    # with +k1+ and +k2+ degrees of freedom over [0, +x+]    
-
+    # Returns the integral of F distribution
+    # with +k1+ and +k2+ degrees of freedom over [0, +x+]
   end
 end

data/lib/distribution/f/ruby.rb

@@ -1,116 +1,118 @@
 module Distribution
   module F
+    # Continuous random number distributions are defined by a probability density function, p(x), such that the probability of x occurring in the infinitesimal range x to x+dx is p dx.
+
+    # The cumulative distribution function for the lower tail P(x) is defined by the integral,
+
+    # P(x) = \int_{-\infty}^{x} dx' p(x')
+    # and gives the probability of a variate taking a value less than x.
+
+    # The cumulative distribution function for the upper tail Q(x) is defined by the integral,
+
+    # Q(x) = \int_{x}^{+\infty} dx' p(x')
+    # and gives the probability of a variate taking a value greater than x.
+
+    # The upper and lower cumulative distribution functions are related by P(x) + Q(x) = 1 and satisfy 0 <= P(x) <= 1, 0 <= Q(x).
     module Ruby_
-        class << self
+      extend Distribution::MathExtension
 
-      def c_pdf(f,df)
-        Distribution::ChiSquare.pdf(f,df)
-      end
-      def pdf(x,d1,d2)
-        Math.sqrt(((d1*x)**d1*(d2**d2)).quo((d1*x+d2)**(d1+d2))).quo( x*Math.beta(d1/2.0, d2/2.0))
-      end
-      # F-distribution ([1])
-      # Integral over [x, \infty) 
-      def q_f(df1, df2, f)
-      if (f <= 0.0) then return 1.0; end
-      if (df1 % 2 != 0 && df2 % 2 == 0)
-      return 1.0 - q_f(df2, df1, 1.0 / f)
-      end
-      cos2 = 1.0 / (1.0 + df1.to_f * f / df2.to_f)
-      sin2 = 1.0 - cos2
-
-      if (df1 % 2 == 0)
-      prob = cos2 ** (df2.to_f / 2.0)
-      temp = prob
-      i = 2
-      while i < df1
-        temp *= (df2.to_f + i - 2) * sin2 / i
-        prob += temp
-        i += 2
-      end
-      return prob
-      end
-      prob = Math.atan(Math.sqrt(df2.to_f / (df1.to_f * f)))
-      temp = Math.sqrt(sin2 * cos2)
-      i = 3
-      while i <= df1
-      prob += temp
-      temp *= (i - 1).to_f * sin2 / i.to_f;
-      i += 2.0
-      end
-      temp *= df1.to_f
-      i = 3
-      while i <= df2
-      prob -= temp
-      temp *= (df1.to_f + i - 2) * cos2 / i.to_f
-      i += 2
-      end
-      prob * 2.0 / Math::PI
-      end
+        # functions needed:
+        # - pdf
+        # - cdf (lower cumulative function, P(x))
+        # - Q(x), upper cumulative function
+        # - mean
+        # - mode
+        # - kurtosis
+        # - skewness
+        # - entropy
+        # - "fit" (maximum likelihood?)
+        # - expected value (given a function)
+        # - lower-tail quantile -> P
+        # - upper tail quantile -> Q
 
-      # inverse of F-distribution ([2])
-      def pfsub(x, y, z)
-      (Math.sqrt(z) - y) / x / 2.0
-      end
+      class << self
+        # F Distribution (Ruby) -- Probability Density Function
+        def pdf(x, n, m)
+          x = x.to_f
+          numerator = ((n * x)**n * (m**m)) / (n * x + m)**(n + m)
+          denominator = x * Math.beta(n / 2.0, m / 2.0)
 
-      # Inverse CDF
-      # [x, \infty)
-      def pf(q, n1, n2)
-        if(q < 0.0 || q > 1.0 || n1 < 1 || n2 < 1)
-        $stderr.printf("Error : Illegal parameter in pf()!\n")
-        return 0.0
-      end
+          Math.sqrt(numerator) / denominator
+        end
 
-      if n1 <= 240 || n2 <= 240
-      eps = 1.0e-5
-      if(n2 == 1) then eps = 1.0e-4 end
-      fw = 0.0
-      s = 1000.0
-      loop do
-      fw += s
-      if s <= eps  then return fw end
-      if (qe = q_f(n1, n2, fw) - q) == 0.0 then return fw end
-      if qe < 0.0
-        fw -= s
-        s /= 10.0 #/
-      end
-      end
-      end
+        # Cumulative Distribution Function.
+        def cdf(x, n, m)
+          x = x.to_f
+          xx = (x * n).to_f / (x * n + m).to_f
+          regularized_beta(xx, n / 2.0, m / 2.0)
+        end
 
-      eps = 1.0e-6
-      qn = q
-      if q < 0.5 then qn = 1.0 - q
-      u = pnorm(qn)
-      w1 = 2.0 / n1 / 9.0
-      w2 = 2.0 / n2 / 9.0
-      w3 = 1.0 - w1
-      w4 = 1.0 - w2
-      u2 = u * u
-      a = w4 * w4 - u2 * w2
-      b = -2. * w3 * w4
-      c = w3 * w3 - u2 * w1
-      d = b * b - 4 * a * c
-      if(d < 0.0)
-      fw = pfsub(a, b, 0.0)
-      else
-      if(a.abs > eps)
-        fw = pfsub(a, b, d)
-      else
-        if(b.abs > eps) then return -c / b end
-        fw = pfsub(a, b, 0.0)
-      end
-      end
-      fw * fw * fw
-      end
-      end
-      # F-distribution interface
-      def cdf(f,n1, n2)
-        1.0 - q_f(n1, n2, f)
-      end
-      def p_value(y, n1, n2)
-        pf(1.0 - y, n1, n2)
-      end
-      
+        # Upper cumulative function.
+        #
+        # If cdf(x, n, m) = p, then q(x, n, m) = 1 - p
+        def q(x, n, m)
+          1.0 - cdf(x, n, m)
+        end
+
+        # Return the F value corresponding to `probability` with degrees of
+        # freedom `n` and `m`.
+        #
+        # If x = quantile(p, n, m), then cdf(x, n, m) = p.
+        #
+        # Taken from:
+        # https://github.com/JuliaLang/Rmath-julia/blob/master/src/qf.c
+        def p_value(probability, n, m)
+          return Float::NAN if n <= 0.0 || m <= 0.0
+
+          if n == Float::INFINITY || n == -Float::INFINITY || m == Float::INFINITY || m == -Float::INFINITY
+            return 1.0
+          end
+
+          if n <= m && m > 4e5
+            return Distribution::ChiSquare.p_value(probability, n) / n.to_f
+          elsif n > 4e5 # thus n > m
+            return m.to_f / Distribution::ChiSquare.p_value(1.0 - probability, m)
+          else
+            # O problema está aqui.
+            tmp = Distribution::Beta.p_value(1.0 - probability, m.to_f / 2, n.to_f / 2)
+            value = (1.0 / tmp - 1.0) * (m.to_f / n.to_f)
+            return value.nan? ? Float::NAN : value
+          end
+        end
+
+        # Complementary quantile function.
+        #
+        # def cquantile(prob, n, m)
+        #   quantile(1.0 - probability, n, m)
+        # end
+
+        # Return the corresponding F value for a p-value `y` with `n` and `m`
+        # degrees of freedom.
+        #
+        # @param y [Float] Value corresponding to the desired p-value. Between 0 and 1.
+        # @param n [Float] Degree of freedom of the first random variable.
+        # @param m [Float] Degree of freedom of the second random variable.
+        # @return [Float] Value of the F distribution that gives a p-value of `y`.
+
+        def mean
+
+        end
+
+        def mode
+
+        end
+
+        def skewness
+
+        end
+
+        def kurtosis
+
+        end
+
+        def entropy
+
+        end
       end
     end
   end

data/lib/distribution/version.rb

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

data/spec/chisquare_spec.rb

@@ -30,6 +30,7 @@ shared_examples_for "Chi-square engine" do
       skip("No #{@engine}.cdf")
     end  
   end
+
   it "should return correct p_value" do
     if @engine.respond_to? :p_value
       1.upto(10) do |k|

data/spec/f_spec.rb

@@ -1,107 +1,109 @@
-require File.expand_path(File.dirname(__FILE__)+"/spec_helper.rb")
+require File.expand_path(File.dirname(__FILE__) + '/spec_helper.rb')
 
 include ExampleWithGSL
 
 describe Distribution::F do
-shared_examples_for "F engine(with rng)" do
-  it "should return correct rng" do
-  pending()
+  shared_examples_for 'F engine (with rng)' do
+    it 'should return correct rng' do
+      pending
+    end
   end
-end
 
-shared_examples_for "F engine(with pdf)" do
-  it_only_with_gsl "should return correct pdf" do
-    if @engine.respond_to? :pdf
-      [0.1,0.5,1,2,10,20,30].each{|f|
-      [2,5,10].each{|n2|
-      [2,5,10].each{|n1|
-      @engine.pdf(f,n1,n2).should be_within(1e-4).of(GSL::Ran.fdist_pdf(f,n1,n2))
-      }
-      }
-      }
-    else
-      pending("No #{@engine}.pdf")
+  shared_examples_for 'F engine (with pdf)' do
+    it_only_with_gsl 'should return correct pdf' do
+      if @engine.respond_to? :pdf
+        [0.1, 0.5, 1, 2, 10, 20, 30].each do |x|
+          [2, 5, 10].product([2, 5, 10]).each do |n, m|
+            expected_value = GSL::Ran.fdist_pdf(x, n, m)
+            @engine.pdf(x, n, m).should be_within(1e-4).of(expected_value)
+          end
+        end
+      else
+        pending("No #{@engine}.pdf")
+      end
     end
   end
-end
 
-shared_examples_for "F engine" do
-  
-  it_only_with_gsl "should return correct cdf" do
-    if @engine.respond_to? :cdf
-      [0.1,0.5,1,2,10,20,30].each{|f|
-      [2,5,10].each{|n2|
-      [2,5,10].each{|n1|
-      @engine.cdf(f,n1,n2).should be_within(1e-4).of(GSL::Cdf.fdist_P(f,n1,n2))
-      
-      }
-      }
-      }
-    else
-      pending("No #{@engine}.cdf")
+  shared_examples_for 'F engine' do
+    it_only_with_gsl 'should return correct cdf' do
+      if @engine.respond_to? :cdf
+        [0.1, 0.5, 1, 2, 10, 20, 30].each do |f|
+          [2, 5, 10].each do |n2|
+            [2, 5, 10].each do |n1|
+              @engine.cdf(f, n1, n2).should be_within(1e-4).of(GSL::Cdf.fdist_P(f, n1, n2))
+            end
+          end
+        end
+      else
+        pending("No #{@engine}.cdf")
+      end
     end
-  
-  end
-  it_only_with_gsl "should return correct p_value" do
-    if @engine.respond_to? :p_value
-  
-    [0.1,0.5,1,2,10,20,30].each{|f|
-    [2,5,10].each{|n2|
-    [2,5,10].each{|n1|
-    area=@engine.cdf(f,n1,n2)
-    @engine.p_value(area,n1,n2).should be_within(1e-4).of(GSL::Cdf.fdist_Pinv(area,n1,n2))
-    }
-    }
-    }
-  
-    
-    else
-      pending("No #{@engine}.p_value")
+
+    it_only_with_gsl 'should return correct p_value', focus: true do
+      if @engine.respond_to? :p_value
+
+        expected_value = GSL::Cdf.fdist_Pinv(0.975, 5, 4.189092917592713)
+        @engine.p_value(0.975, 5, 4.189092917592713).should be_within(1e-4).of(expected_value)
+
+        [0.1, 0.5, 1, 2, 10, 20, 30].each do |f|
+          [2, 5, 10].each do |n2|
+            [2, 5, 10].each do |n1|
+              area = @engine.cdf(f, n1, n2)
+              expected_value = GSL::Cdf.fdist_Pinv(area, n1, n2)
+
+              @engine.p_value(area, n1, n2).should be_within(1e-4).of(expected_value)
+            end
+          end
+        end
+      else
+        pending("No #{@engine}.p_value")
+      end
     end
   end
-end
 
-  describe "singleton" do
+  describe 'singleton' do
     before do
-      @engine=Distribution::F
+      @engine = Distribution::F
     end
-    it_should_behave_like "F engine"    
-    it_should_behave_like "F engine(with pdf)"    
+
+    it_should_behave_like 'F engine'
+    it_should_behave_like 'F engine (with pdf)'
   end
-  
+
   describe Distribution::F::Ruby_ do
     before do
-      @engine=Distribution::F::Ruby_
+      @engine = Distribution::F::Ruby_
     end
-    it_should_behave_like "F engine"    
-    it_should_behave_like "F engine(with pdf)"    
+    it_should_behave_like 'F engine'
+    it_should_behave_like 'F engine (with pdf)'
   end
+
   if Distribution.has_gsl?
     describe Distribution::F::GSL_ do
       before do
-        @engine=Distribution::F::GSL_
+        @engine = Distribution::F::GSL_
       end
-    it_should_behave_like "F engine"    
-    it_should_behave_like "F engine(with pdf)"    
+      it_should_behave_like 'F engine'
+      it_should_behave_like 'F engine (with pdf)'
     end
-  end  
+  end
+
   if Distribution.has_statistics2?
     describe Distribution::F::Statistics2_ do
       before do
-        @engine=Distribution::F::Statistics2_
+        @engine = Distribution::F::Statistics2_
       end
-    it_should_behave_like "F engine"    
-    end  
+      it_should_behave_like 'F engine'
+    end
   end
-  
+
   if Distribution.has_java?
     describe Distribution::F::Java_ do
       before do
-        @engine=Distribution::F::Java_
+        @engine = Distribution::F::Java_
       end
-    it_should_behave_like "F engine"    
-    it_should_behave_like "F engine(with pdf)"    
-    end  
+      it_should_behave_like 'F engine'
+      it_should_behave_like 'F engine (with pdf)'
+    end
   end
-  
 end

data/spec/spec_helper.rb

@@ -26,8 +26,8 @@ RSpec.configure do |config|
 end
 
 module ExampleWithGSL
-  def it_only_with_gsl(name,&block)
-    it(name) do
+  def it_only_with_gsl(name,opts={},&block)
+    it(name, opts) do
       if Distribution.has_gsl?
         instance_eval(&block)
       else

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: distribution
 version: !ruby/object:Gem::Version
-  version: 0.7.2
+  version: 0.7.3
 platform: ruby
 authors:
 - Claudio Bustos
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2015-04-03 00:00:00.000000000 Z
+date: 2015-05-28 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -188,7 +188,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.2.2
+rubygems_version: 2.4.5
 signing_key: 
 specification_version: 4
 summary: Distribution