distribution 0.6.0 → 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,82 +2,87 @@ 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 * 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
+              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
+              end
+            end
+
+            v
           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)
+
+        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
+          chi2 = chi2.to_f
+          if (df & 1) != 0
+            chi = Math.sqrt(chi2)
+
+            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
+              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
+
+        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

@@ -2,20 +2,26 @@ module Distribution
   module Exponential
     module Ruby_
       class << self
-        def rng(l)
-	  lambda {p_value(rand(),l)}
-	end
-	def pdf(x,l)
-          return 0 if x<0
-          l*Math.exp(-l*x)
+        def rng(l, opts = {})
+          rng = opts[:random] || Random
+          -> { p_value(rng.rand, l) }
         end
-        def cdf(x,l)
-          return 0 if x<0
-          1-Math.exp(-l*x)
+
+        def pdf(x, l)
+          return 0 if x < 0
+          l * Math.exp(-l * x)
         end
-        def p_value(pr,l)
-          (-Math.log(1-pr)).quo(l)
+
+        def cdf(x, l)
+          return 0 if x < 0
+          1 - Math.exp(-l * x)
         end
+
+        def quantile(pr, l)
+          (-Math.log(1 - pr)).quo(l)
+        end
+
+        alias_method :p_value, :quantile
       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