distribution 0.6.0 → 0.8.0

data/lib/distribution/f/gsl.rb

@@ -1,27 +1,31 @@
 module Distribution
   module F
-  module GSL_
-    class << self
-      def pdf(x,k1,k2)
-        GSL::Ran.fdist_pdf(x.to_f,k1,k2)
-      end
-      # Return the P-value of the corresponding integral with 
-      # k degrees of freedom
-      #
-      #   Distribution::F.p_value(0.95,1,2)
-      def p_value(pr,k1,k2)
-        GSL::Cdf.fdist_Pinv(pr.to_f,k1,k2)
-      end
-      # F cumulative distribution function (cdf).
-      # 
-      # Returns the integral of F-distribution 
-      # with k1 and k2 degrees of freedom
-      # over [0, x].
-      #   Distribution::F.cdf(20,3,2)
-      # 
-      def cdf(x, k1, k2)
-        GSL::Cdf.fdist_P(x.to_f.to_f,k1,k2)
-      end
+    module GSL_
+      class << self
+        def pdf(x, k1, k2)
+          GSL::Ran.fdist_pdf(x.to_f, k1, k2)
+        end
+
+        # F cumulative distribution function (cdf).
+        #
+        # Returns the integral of F-distribution
+        # with k1 and k2 degrees of freedom
+        # over [0, x].
+        #   Distribution::F.cdf(20,3,2)
+        #
+        def cdf(x, k1, k2)
+          GSL::Cdf.fdist_P(x.to_f.to_f, k1, k2)
+        end
+
+        # Return the P-value of the corresponding integral with
+        # k degrees of freedom
+        #
+        #   Distribution::F.p_value(0.95,1,2)
+        def quantile(pr, k1, k2)
+          GSL::Cdf.fdist_Pinv(pr.to_f, k1, k2)
+        end
+
+        alias_method :p_value, :quantile
       end
     end
   end

data/lib/distribution/f/java.rb

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

data/lib/distribution/f/ruby.rb

@@ -1,116 +1,115 @@
 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 quantile(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
+
+        alias_method :p_value, :quantile
+
+        # 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/f/statistics2.rb

@@ -1,26 +1,29 @@
 module Distribution
   module F
     module Statistics2_
-    class << self
-      # Return the P-value of the corresponding integral with 
-      # k degrees of freedom
-      #
-      #   Distribution::F.p_value(0.95,1,2)
-      # Statistics2 have some problem with extreme values
-      def p_value(pr,k1,k2)
-        Statistics2.pfdist(k1,k2, pr)
+      class << self
+        # F cumulative distribution function (cdf).
+        #
+        # Returns the integral of F-distribution
+        # with k1 and k2 degrees of freedom
+        # over [0, x].
+        #   Distribution::F.cdf(20,3,2)
+        #
+        def cdf(x, k1, k2)
+          Statistics2.fdist(k1, k2, x)
+        end
+
+        # Return the P-value of the corresponding integral with
+        # k degrees of freedom
+        #
+        #   Distribution::F.p_value(0.95,1,2)
+        # Statistics2 have some problem with extreme values
+        def quantile(pr, k1, k2)
+          Statistics2.pfdist(k1, k2, pr)
+        end
+
+        alias_method :p_value, :quantile
       end
-      # F cumulative distribution function (cdf).
-      # 
-      # Returns the integral of F-distribution 
-      # with k1 and k2 degrees of freedom
-      # over [0, x].
-      #   Distribution::F.cdf(20,3,2)
-      # 
-      def cdf(x, k1, k2)
-        Statistics2.fdist(k1, k2,x)
-      end
-    end
     end
   end
 end

data/lib/distribution/gamma.rb

@@ -5,15 +5,15 @@ require 'distribution/gamma/java'
 
 module Distribution
   # From Wikipedia:
-  #    The gamma distribution is a two-parameter family of 
+  #    The gamma distribution is a two-parameter family of
   #    continuous probability distributions. It has a scale parameter a
   #    and a shape parameter b.
-  # 
+  #
   # Calculate pdf, cdf and inverse cdf for Gamma Distribution.
   #
   module Gamma
     extend Distributable
-    SHORTHAND='gamma'
+    SHORTHAND = 'gamma'
     create_distribution_methods
 
     ##
@@ -21,7 +21,6 @@ module Distribution
     # Returns PDF of of Gamma distribution with +a+ as scale
     # parameter and +b+ as shape parameter
 
-
     ##
     # :singleton-method: cdf(x,a,b)
     # Returns the integral of Gamma distribution with +a+ as scale
@@ -29,9 +28,8 @@ module Distribution
 
     ##
     # :singleton-method: p_value(qn,a,b)
-    # Return the upper limit for the integral of a 
-    # gamma distribution which returns +qn+ 
+    # Return the upper limit for the integral of a
+    # gamma distribution which returns +qn+
     # with scale +a+ and shape +b+
-
   end
 end

data/lib/distribution/gamma/gsl.rb

@@ -2,22 +2,26 @@ module Distribution
   module Gamma
     module GSL_
       class << self
-        def pdf(x,a,b)
-          GSL::Ran::gamma_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::gamma_Pinv(pr.to_f, a.to_f, b.to_f)
+        def pdf(x, a, b)
+          GSL::Ran.gamma_pdf(x.to_f, a.to_f, b.to_f)
         end
+
         # Chi-square cumulative distribution function (cdf).
         #
         # Returns the integral of Chi-squared distribution
         # with k degrees of freedom over [0, x]
         #
-        def cdf(x,a,b)
-          GSL::Cdf::gamma_P(x.to_f, a.to_f, b.to_f)
+        def cdf(x, a, b)
+          GSL::Cdf.gamma_P(x.to_f, a.to_f, b.to_f)
+        end
+
+        # Return the P-value of the corresponding integral with
+        # k degrees of freedom
+        def quantile(pr, a, b)
+          GSL::Cdf.gamma_Pinv(pr.to_f, a.to_f, b.to_f)
         end
+
+        alias_method :p_value, :quantile
       end
     end
   end

data/lib/distribution/gamma/java.rb

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

data/lib/distribution/gamma/ruby.rb

@@ -3,7 +3,6 @@ module Distribution
   module Gamma
     module Ruby_
       class << self
-
         include Math
         # Gamma distribution probability density function
         #
@@ -22,7 +21,7 @@ module Distribution
         # ==References
         # * http://www.gnu.org/software/gsl/manual/html_node/The-Gamma-Distribution.html
         # * http://en.wikipedia.org/wiki/Gamma_distribution
-        def pdf(x,a,b)
+        def pdf(x, a, b)
           return 0 if x < 0
           if x == 0
             return 1.quo(b) if a == 1
@@ -30,23 +29,18 @@ module Distribution
           elsif a == 1
             Math.exp(-x.quo(b)).quo(b)
           else
-            Math.exp((a-1)*Math.log(x.quo(b)) - x.quo(b) - Math.lgamma(a).first).quo(b)
+            Math.exp((a - 1) * Math.log(x.quo(b)) - x.quo(b) - Math.lgamma(a).first).quo(b)
           end
         end
 
         # Gamma cumulative distribution function
-        def cdf(x,a,b)
+        def cdf(x, a, b)
           return 0.0 if x <= 0.0
 
           y = x.quo(b)
-          return (1-Math::IncompleteGamma.q(a, y)) if y > a
-          return (Math::IncompleteGamma.p(a, y))
+          return (1 - Math::IncompleteGamma.q(a, y)) if y > a
+          (Math::IncompleteGamma.p(a, y))
         end
-
-        #def p_value(pr,a,b)
-        #  cdf(1.0-pr,a,b)
-        #end
-
       end
     end
   end