distribution 0.7.3 → 0.8.0

data/lib/distribution/chisquare.rb

@@ -4,27 +4,25 @@ require 'distribution/chisquare/statistics2'
 require 'distribution/chisquare/java'
 module Distribution
   # Calculate cdf and inverse cdf for Chi Square Distribution.
-  # 
+  #
   module ChiSquare
     extend Distributable
-    SHORTHAND='chisq'
+    SHORTHAND = 'chisq'
     create_distribution_methods
-    
+
     ##
     # :singleton-method: pdf(x)
-    # Returns PDF of of Chi-squared distribution 
+    # 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+]    
+    # 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 
+    # Return the P-value of the corresponding integral +qn+ with
     # +k+ degrees of freedom
-    
   end
 end

data/lib/distribution/chisquare/gsl.rb

@@ -2,25 +2,30 @@ module Distribution
   module ChiSquare
     module GSL_
       class << self
-      def rng(k,seed=nil)
-        
-      end
-      def pdf(x,k)
-        GSL::Ran::chisq_pdf(x.to_f,k.to_i)
-      end
-      # Return the P-value of the corresponding integral with 
-      # k degrees of freedom
-      def p_value(pr,k)
-        GSL::Cdf::chisq_Pinv(pr.to_f,k.to_i)
-      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.to_f,k.to_i)
-      end
+        def rng(_k, _seed = nil)
+          nil
+        end
+
+        def pdf(x, k)
+          GSL::Ran.chisq_pdf(x.to_f, k.to_i)
+        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.to_f, k.to_i)
+        end
+
+        # Return the P-value of the corresponding integral with
+        # k degrees of freedom
+        def quantile(pr, k)
+          GSL::Cdf.chisq_Pinv(pr.to_f, k.to_i)
+        end
+
+        alias_method :p_value, :quantile
       end
     end
   end

data/lib/distribution/chisquare/java.rb

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

data/lib/distribution/chisquare/ruby.rb

@@ -2,27 +2,25 @@ module Distribution
   module ChiSquare
     module Ruby_
       class << self
-      
         include Math
-        def pdf(x,n)
+        def pdf(x, n)
           if n == 1
-            1.0/Math.sqrt(2 * Math::PI * x) * Math::E**(-x/2.0)
+            1.0 / Math.sqrt(2 * Math::PI * x) * Math::E**(-x / 2.0)
           elsif n == 2
-            0.5 * Math::E**(-x/2.0)
+            0.5 * Math::E**(-x / 2.0)
           else
             n = n.to_f
-            n2 = n/2
+            n2 = n / 2
             x = x.to_f
-            1.0 / 2**n2 / gamma(n2) * x**(n2 - 1.0) * Math.exp(-x/2.0)
-          end        
+            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 = 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
@@ -34,26 +32,22 @@ module Distribution
             s = 10.0
             loop do
               v += s
-              if s <= eps then break end
+              break if s <= eps
               if (qe = q_chi2(n, v) - y) == 0.0 then break end
               if qe < 0.0
-              v -= s
-              s /= 10.0
+                v -= s
+                s /= 10.0
+              end
             end
-          end
 
-          v
+            v
           end
         end
 
-        def p_value(pr,k)
-          pchi2(k, 1.0-pr)
+        def cdf(x, k)
+          1.0 - q_chi2(k, x)
         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)
@@ -61,28 +55,34 @@ module Distribution
           if (df & 1) != 0
             chi = Math.sqrt(chi2)
 
-            if (df == 1) then return 2 * (1.0-Distribution::Normal.cdf(chi)); end
+            return 2 * (1.0 - Distribution::Normal.cdf(chi)) if (df == 1)
             s = t = chi * Math.exp(-0.5 * chi2) / SQ2PI
             k = 3
 
             while k < df
-              t *= chi2 / k;  s += t;
+              t *= chi2 / k;  s += t
               k += 2
             end
 
-            2 * (1.0-(Distribution::Normal.cdf(chi)) + s)
+            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;
+              t *= chi2 / k;  s += t
               k += 2
             end
             s
           end
         end
+
+        def quantile(pr, k)
+          pchi2(k, 1.0 - pr)
+        end
+
+        alias_method :p_value, :quantile
       end
     end
   end

data/lib/distribution/chisquare/statistics2.rb

@@ -2,20 +2,23 @@ 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)
+        # 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
+
+        # Return the P-value of the corresponding integral with
+        # k degrees of freedom
+        def quantile(pr, k)
+          Statistics2.pchi2X_(k.to_i, pr)
+        end
+
+        alias_method :p_value, :quantile
       end
     end
   end
-  end
 end

data/lib/distribution/distributable.rb

@@ -0,0 +1,40 @@
+module Distribution
+  # Magic module
+  module Distributable #:nodoc:
+    # Create methods for each module and add methods to
+    # Distribution::Shorthand.
+    #
+    # Traverse Distribution.libraries_order adding
+    # methods availables for each engine module on
+    # the current library
+    #
+    # Kids: Metaprogramming trickery! Don't do at work.
+    # This section was created between a very long reunion
+    # and a 456 Km. travel
+    def create_distribution_methods
+      Distribution.libraries_order.each do |l_name|
+        if const_defined? l_name
+          l = const_get(l_name)
+          # Add methods from engine to base base, if not yet included
+          l.singleton_methods.each do |m|
+            unless singleton_methods.include? m
+              define_method(m) do |*args|
+                l.send(m, *args)
+              end
+              # Add method to Distribution::Shorthand
+              sh = const_get(:SHORTHAND)
+              Distribution::Shorthand.add_shortcut(sh, m) do |*args|
+                l.send(m, *args)
+              end
+
+              module_function m
+            end
+          end
+        end
+      end
+
+      # create alias for common methods
+      alias_method :inverse_cdf, :p_value if singleton_methods.include? :p_value
+    end
+  end
+end

data/lib/distribution/exponential.rb

@@ -1,19 +1,18 @@
 require 'distribution/exponential/ruby'
 require 'distribution/exponential/gsl'
-#require 'distribution/exponential/java'
-
+# require 'distribution/exponential/java'
 
 module Distribution
   # From Wikipedia:
-  #   In probability theory and statistics, the exponential distribution 
+  #   In probability theory and statistics, the exponential distribution
   #   (a.k.a. negative exponential distribution) is a family of continuous
   #   probability distributions. It describes the time between events in a
-  #   Poisson process, i.e. a process in which events occur continuously 
+  #   Poisson process, i.e. a process in which events occur continuously
   #   and independently at a constant average rate.
   #
   # Parameter +l+ is the rate parameter, the number of occurrences/unit time.
   module Exponential
-    SHORTHAND='expo'
+    SHORTHAND = 'expo'
     extend Distributable
     create_distribution_methods
     ##

data/lib/distribution/exponential/gsl.rb

@@ -2,18 +2,22 @@ module Distribution
   module Exponential
     module GSL_
       class << self
-        def pdf(x,l)
-          return 0 if x<0
-          GSL::Ran.exponential_pdf(x,1/l.to_f)
+        def pdf(x, l)
+          return 0 if x < 0
+          GSL::Ran.exponential_pdf(x, 1 / l.to_f)
         end
-        def cdf(x,l)
-          return 0 if x<0
-          GSL::Cdf.exponential_P(x,1/l.to_f)
+
+        def cdf(x, l)
+          return 0 if x < 0
+          GSL::Cdf.exponential_P(x, 1 / l.to_f)
         end
-        def p_value(pr,l)
-          GSL::Cdf.exponential_Pinv(pr,1/l.to_f)
+
+        def quantile(pr, l)
+          GSL::Cdf.exponential_Pinv(pr, 1 / l.to_f)
         end
+
+        alias_method :p_value, :quantile
       end
     end
   end
-end
+end

data/lib/distribution/exponential/ruby.rb

@@ -4,19 +4,24 @@ module Distribution
       class << self
         def rng(l, opts = {})
           rng = opts[:random] || Random
-          lambda {p_value(rng.rand,l)}
+          -> { p_value(rng.rand, l) }
         end
-        def pdf(x,l)
-          return 0 if x<0
-          l*Math.exp(-l*x)
+
+        def pdf(x, l)
+          return 0 if x < 0
+          l * Math.exp(-l * x)
         end
-        def cdf(x,l)
-          return 0 if x<0
-          1-Math.exp(-l*x)
+
+        def cdf(x, l)
+          return 0 if x < 0
+          1 - Math.exp(-l * x)
         end
-        def p_value(pr,l)
-          (-Math.log(1-pr)).quo(l)
+
+        def quantile(pr, l)
+          (-Math.log(1 - pr)).quo(l)
         end
+
+        alias_method :p_value, :quantile
       end
     end
   end

data/lib/distribution/f.rb

@@ -6,7 +6,7 @@ module Distribution
   # Calculate cdf and inverse cdf for F Distribution.
   #
   module F
-    SHORTHAND='fdist'
+    SHORTHAND = 'fdist'
     extend Distributable
     create_distribution_methods
 

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

@@ -16,19 +16,19 @@ module Distribution
     module Ruby_
       extend Distribution::MathExtension
 
-        # 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
+      # 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
 
       class << self
         # F Distribution (Ruby) -- Probability Density Function
@@ -61,7 +61,7 @@ module Distribution
         #
         # Taken from:
         # https://github.com/JuliaLang/Rmath-julia/blob/master/src/qf.c
-        def p_value(probability, n, m)
+        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
@@ -80,6 +80,8 @@ module Distribution
           end
         end
 
+        alias_method :p_value, :quantile
+
         # Complementary quantile function.
         #
         # def cquantile(prob, n, m)
@@ -95,23 +97,18 @@ module Distribution
         # @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