distribution 0.1.0

data/lib/distribution/chisquare.rb

@@ -0,0 +1,29 @@
+require 'distribution/chisquare/ruby'
+require 'distribution/chisquare/gsl'
+require 'distribution/chisquare/statistics2'
+module Distribution
+  # Calculate cdf and inverse cdf for Chi Square Distribution.
+  # 
+  module ChiSquare
+    extend Distributable
+    SHORTHAND='chisq'
+    create_distribution_methods
+    
+    ##
+    # :singleton-method: pdf(x)
+    # Returns PDF of of Chi-squared distribution 
+    # with +k+ degrees of freedom
+    
+    
+    ##
+    # :singleton-method: cdf(x,k)
+    # Returns the integral of Chi-squared 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
+    
+  end
+end

data/lib/distribution/chisquare/gsl.rb

@@ -0,0 +1,27 @@
+module Distribution
+  module ChiSquare
+    module GSL_
+      class << self
+      def rng(k,seed=nil)
+        
+      end
+      def pdf(x,k)
+        GSL::Ran::chisq_pdf(x,k)
+      end
+      # Return the P-value of the corresponding integral with 
+      # k degrees of freedom
+      def p_value(pr,k)
+        GSL::Cdf::chisq_Pinv(pr,k)
+      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, k)
+        GSL::Cdf::chisq_P(x,k)
+      end
+      end
+    end
+  end
+end

data/lib/distribution/chisquare/ruby.rb

@@ -0,0 +1,85 @@
+module Distribution
+  module ChiSquare
+    module Ruby_
+      class << self
+      
+        include Distribution::MathExtension
+      
+        def pdf(x,n)
+          if n == 1
+            1.0/Math.sqrt(2 * Math::PI * x) * Math::E**(-x/2.0)
+          elsif n == 2
+            0.5 * Math::E**(-x/2.0)
+          else
+            n = n.to_f
+            n2 = n/2
+            x = x.to_f
+            1.0 / 2**n2 / gamma(n2) * x**(n2 - 1.0) * Math.exp(-x/2.0)
+          end        
+        end
+        
+        
+        # CDF Inverse over [x, \infty)
+        # 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
+          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)
+          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
+          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
+        
+        # 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
+        end
+        
+        
+      end
+    end
+  end
+end

data/lib/distribution/chisquare/statistics2.rb

@@ -0,0 +1,21 @@
+module Distribution
+  module ChiSquare
+    module Statistics2_
+      class << self
+      # Return the P-value of the corresponding integral with 
+      # k degrees of freedom
+      def p_value(pr,k)
+        Statistics2.pchi2X_(k.to_i, pr)
+      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, k)
+        Statistics2.chi2dist(k.to_i,x)
+      end
+    end
+  end
+  end
+end

data/lib/distribution/f.rb

@@ -0,0 +1,28 @@
+require 'distribution/f/ruby'
+require 'distribution/f/gsl'
+require 'distribution/f/statistics2'
+module Distribution
+  # Calculate cdf and inverse cdf for Chi Square Distribution.
+  # 
+  module F
+    SHORTHAND='f'  
+    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+]    
+
+    ##
+    # :singleton-method: p_value(qn, k1, k2)
+    # 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+]    
+
+  end
+end

data/lib/distribution/f/gsl.rb

@@ -0,0 +1,28 @@
+module Distribution
+  module F
+  module GSL_
+    class << self
+      def pdf(x,k1,k2)
+        GSL::Ran.fdist_pdf(x,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,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,k1,k2)
+      end
+      end
+    end
+  end
+end

data/lib/distribution/f/ruby.rb

@@ -0,0 +1,117 @@
+module Distribution
+  module F
+    module Ruby_
+        class << self
+
+      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
+
+      # inverse of F-distribution ([2])
+      def pfsub(x, y, z)
+      (Math.sqrt(z) - y) / x / 2.0
+      end
+
+      # 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
+
+      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
+
+      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
+      
+      end
+    end
+  end
+end

data/lib/distribution/f/statistics2.rb

@@ -0,0 +1,26 @@
+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)
+      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/math_extension.rb

@@ -0,0 +1,72 @@
+# Useful additions to Math
+module Distribution
+  module MathExtension
+    # Factorial for n
+    def factorial(n)
+      sum=1
+      2.upto(n) do |i|
+        sum*=n
+      end
+      sum
+    end
+    
+    # Beta function.
+    # Source:
+    # * http://mathworld.wolfram.com/BetaFunction.html
+    def beta(x,y)
+      (gamma(x)*gamma(y)).quo(gamma(x+y))
+    end
+    
+    LOG_2PI = Math.log(2 * Math::PI)# log(2PI)
+    N = 8
+    B0  = 1.0
+    B1  = -1.0 / 2.0
+    B2  = 1.0 / 6.0
+    B4  = -1.0 / 30.0
+    B6  =  1.0 / 42.0
+    B8  = -1.0 / 30.0
+    B10 =  5.0 / 66.0
+    B12 = -691.0 / 2730.0
+    B14 =  7.0 / 6.0
+    B16 = -3617.0 / 510.0
+    # From statistics2
+    def loggamma(x)
+      v = 1.0
+      while (x < N)
+        v *= x
+        x += 1.0
+      end
+      w = 1.0 / (x * x)
+      ret = B16 / (16 * 15)
+      ret = ret * w + B14 / (14 * 13)
+      ret = ret * w + B12 / (12 * 11)
+      ret = ret * w + B10 / (10 *  9)
+      ret = ret * w + B8  / ( 8 *  7)
+      ret = ret * w + B6  / ( 6 *  5)
+      ret = ret * w + B4  / ( 4 *  3)
+      ret = ret * w + B2  / ( 2 *  1)
+      ret = ret / x + 0.5 * LOG_2PI - Math.log(v) - x + (x - 0.5) * Math.log(x)
+      ret
+    end
+    # Gamma function.
+    # From statistics2    
+    def gamma(x)
+      if (x < 0.0)
+        return Math::PI / (Math.sin(Math.PI * x) * Math.exp(loggamma(1 - x))) #/
+      end
+      Math.exp(loggamma(x))
+    end
+  end
+end
+
+module Math
+  include Distribution::MathExtension
+  module_function :factorial, :beta, :gamma
+end
+
+# Necessary on Ruby 1.9
+module CMath # :nodoc:
+  include Distribution::MathExtension
+  module_function :factorial, :beta, :gamma  
+end
+