distribution 0.7.3 → 0.8.0

data/lib/distribution/poisson.rb

@@ -2,33 +2,31 @@ require 'distribution/poisson/ruby'
 require 'distribution/poisson/gsl'
 require 'distribution/poisson/java'
 
-
 module Distribution
   # From Wikipedia
-  #  In probability theory and statistics, the Poisson distribution is 
-  #  a discrete probability distribution that expresses the probability of 
-  #  a number of events occurring in a fixed period of time if these 
-  #  events occur with a known average rate and independently of the time 
+  #  In probability theory and statistics, the Poisson distribution is
+  #  a discrete probability distribution that expresses the probability of
+  #  a number of events occurring in a fixed period of time if these
+  #  events occur with a known average rate and independently of the time
   #  since the last event.
   module Poisson
-    SHORTHAND='pois'
+    SHORTHAND = 'pois'
     extend Distributable
     create_distribution_methods
 
     ##
     # :singleton-method: pdf(k , l)
-    # PDF for Poisson distribution, 
-    # [+k+] is the number of occurrences of an event 
+    # PDF for Poisson distribution,
+    # [+k+] is the number of occurrences of an event
     # [+l+] is a positive real number, equal to the expected number of occurrences that occur during the given interval.
-    
+
     ##
     # :singleton-method: cdf(k , l)
     # CDF for Poisson distribution
-    # [+k+] is the number of occurrences of an event 
-    # [+l+] is a positive real number, equal to the expected number of occurrences that occur during the given interval.    
-    
+    # [+k+] is the number of occurrences of an event
+    # [+l+] is a positive real number, equal to the expected number of occurrences that occur during the given interval.
+
     # TODO: Not implemented yet
     # :singleton-method: p_value(pr , l)
-
   end
 end

data/lib/distribution/poisson/gsl.rb

@@ -2,16 +2,16 @@ module Distribution
   module Poisson
     module GSL_
       class << self
-        def pdf(k,l)
-          return 0 if k<0
-          GSL::Ran.poisson_pdf(k,l.to_f)
+        def pdf(k, l)
+          return 0 if k < 0
+          GSL::Ran.poisson_pdf(k, l.to_f)
         end
-        def cdf(k,l)
-          return 0 if k<0
+
+        def cdf(k, l)
+          return 0 if k < 0
           GSL::Cdf.poisson_P(k, l.to_f)
         end
-        
       end
     end
   end
-end
+end

data/lib/distribution/poisson/java.rb

@@ -2,30 +2,25 @@ module Distribution
   module Poisson
     module Java_
       class << self
-      #==
-      # Create the PoissonDistributionImpl object for use in calculations
-      # with mean of l
-      def create_distribution(l)
-        PoissonDistributionImpl.new(l)
-      end
-      
-      #==
-      # 
-      def pdf(k,l)
-        dist = create_distribution(l)
-        dist.probability(k)
-      end
-      
-      def cdf(k,l)
-        dist = create_distribution(l)
-        dist.cumulativeProbability(k)
-      end
-      
-#      def p_value(pr,l)
-#        dist = create_distribution(l)
-#        dist.inverseCumulativeProbability(pr)
-#      end
+        #==
+        # Create the PoissonDistributionImpl object for use in calculations
+        # with mean of l
+        def create_distribution(l)
+          PoissonDistributionImpl.new(l)
+        end
+
+        #==
+        #
+        def pdf(k, l)
+          dist = create_distribution(l)
+          dist.probability(k)
+        end
+
+        def cdf(k, l)
+          dist = create_distribution(l)
+          dist.cumulativeProbability(k)
+        end
       end
     end
   end
-end
+end

data/lib/distribution/poisson/ruby.rb

@@ -2,20 +2,49 @@ module Distribution
   module Poisson
     module Ruby_
       class << self
-        def pdf(k,l )
-          (l**k*Math.exp(-l)).quo(Math.factorial(k))
+
+        # Return a Proc object which returns a random number drawn
+        # from the poisson distribution with lambda.
+        #
+        # == Arguments
+        #   * +lambda_val+  - mean of the poisson distribution
+        #   * +seed+  - seed, an integer value to set the initial state
+        #
+        # == Algorithm
+        #   * Donald Knuth
+        #
+        def rng(lambda_val = 1, seed = nil)
+          seed = Random.new_seed if seed.nil?
+          r = Random.new(seed).rand
+          x = 0
+          l = Math.exp(-lambda_val)
+          s = l
+          while r > s
+            x += 1
+            l *= lambda_val / x.to_f
+            s += l
+          end
+          x
+        end
+
+        def pdf(k, l)
+          (l**k * Math.exp(-l)).quo(Math.factorial(k))
         end
-        def cdf(k,l)
-          Math.exp(-l)*(0..k).inject(0) {|ac,i| ac+ (l**i).quo(Math.factorial(i))}
+
+        def cdf(k, l)
+          Math.exp(-l) * (0..k).inject(0) { |ac, i| ac + (l**i).quo(Math.factorial(i)) }
         end
-        def p_value(prob,l)
-          ac=0
+
+        def quantile(prob, l)
+          ac = 0
           (0..100).each do |i|
-            ac+=pdf(i,l)
-            return i if prob<=ac
+            ac += pdf(i, l)
+            return i if prob <= ac
           end
         end
+
+        alias_method :p_value, :quantile
       end
     end
   end
-end
+end

data/lib/distribution/shorthand.rb

@@ -0,0 +1,17 @@
+module Distribution
+  module Shorthand
+    EQUIVALENCES = { p_value: :p, cdf: :cdf, pdf: :pdf, rng: :r,
+                     exact_pdf: :epdf, exact_cdf: :ecdf, exact_p_value: :ep }
+
+    def self.add_shortcut(shortcut, method, &block)
+      if EQUIVALENCES.include? method.to_sym
+        name = shortcut + "_#{method}"
+        define_method(name, &block)
+
+        name = shortcut + "_#{EQUIVALENCES[method.to_sym]}"
+        define_method(name, &block)
+
+      end
+    end
+  end
+end

data/lib/distribution/t.rb

@@ -6,26 +6,24 @@ require 'distribution/t/gsl'
 require 'distribution/t/java'
 
 module Distribution
+  # Calculate statisticals for T Distribution.
+  module T
+    SHORTHAND = 'tdist'
+    extend Distributable
+    create_distribution_methods
 
-    # Calculate statisticals for T Distribution.
-    module T
-      SHORTHAND='tdist'  
-      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+]    
-    end
+    # Returns the integral of T distribution
+    # with +k+ degrees of freedom over [0, +x+]
+  end
 end

data/lib/distribution/t/gsl.rb

@@ -1,29 +1,32 @@
 module Distribution
   module T
-  module GSL_
-    class << self
-      
-      def pdf(x,k)
-        GSL::Ran.tdist_pdf(x,k)
-      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,k)
-        GSL::Cdf.tdist_Pinv(pr,k)
-      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, k)
-        GSL::Cdf.tdist_P(x.to_f, k)
+    module GSL_
+      class << self
+        def pdf(x, k)
+          GSL::Ran.tdist_pdf(x, k)
+        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, k)
+          GSL::Cdf.tdist_P(x.to_f, k)
+        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, k)
+          GSL::Cdf.tdist_Pinv(pr, k)
+        end
+
+        alias_method :p_value, :quantile
       end
     end
   end
-  end
-end
+end

data/lib/distribution/t/java.rb

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

data/lib/distribution/t/ruby.rb

@@ -1,111 +1,110 @@
 module Distribution
   module T
-  module Ruby_
-    class << self
-      def pdf(t,v)
-        ((Math.gamma((v+1) / 2.0)) / (Math.sqrt(v*Math::PI)*Math.gamma(v/2.0))) * ((1+(t**2 / v.to_f))**(-(v+1) / 2.0))
-        
-      end
-      # Returns the integral of t-distribution with n degrees of freedom over (-Infty, x].
-      def cdf(t, n)
-        p_t(n, t)
-      end
-      
-      # t-distribution ([1])
-      # (-\infty, x]
-      def p_t(df, t)
-        if df.to_i!=df
-          x=(t+Math.sqrt(t**2+df)) / (2*Math.sqrt(t**2+df))
-          return Math.regularized_beta(x,df/2.0,df/2.0)
+    module Ruby_
+      class << self
+        def pdf(t, v)
+          ((Math.gamma((v + 1) / 2.0)) / (Math.sqrt(v * Math::PI) * Math.gamma(v / 2.0))) * ((1 + (t**2 / v.to_f))**(-(v + 1) / 2.0))
         end
-        df=df.to_i
-        c2 = df.to_f / (df + t * t);
-        s = Math.sqrt(1.0 - c2)
-        s = -s if t < 0.0
-        p = 0.0;
-        i = df % 2 + 2
-        while i <= df
-          p += s
-          s *= (i - 1) * c2 / i
-          i += 2
+
+        # Returns the integral of t-distribution with n degrees of freedom over (-Infty, x].
+        def cdf(t, n)
+          p_t(n, t)
         end
-        
-        if df.is_a? Float or df & 1 != 0
-          0.5+(p*Math.sqrt(c2)+Math.atan(t/Math.sqrt(df))) / Math::PI
-        else
-          (1.0 + p) / 2.0
+
+        # t-distribution ([1])
+        # (-\infty, x]
+        def p_t(df, t)
+          if df.to_i != df
+            x = (t + Math.sqrt(t**2 + df)) / (2 * Math.sqrt(t**2 + df))
+            return Math.regularized_beta(x, df / 2.0, df / 2.0)
+          end
+          df = df.to_i
+          c2 = df.to_f / (df + t * t)
+          s = Math.sqrt(1.0 - c2)
+          s = -s if t < 0.0
+          p = 0.0
+          i = df % 2 + 2
+          while i <= df
+            p += s
+            s *= (i - 1) * c2 / i
+            i += 2
+          end
+
+          if df.is_a?(Float) || df & 1 != 0
+            0.5 + (p * Math.sqrt(c2) + Math.atan(t / Math.sqrt(df))) / Math::PI
+          else
+            (1.0 + p) / 2.0
+          end
         end
-      end
-      
-      
-      # inverse of t-distribution ([2])
-      # (-\infty, -q/2] + [q/2, \infty)
-      def ptsub(q, n)
-      q = q.to_f
-      if(n == 1 && 0.001 < q && q < 0.01)
-      eps = 1.0e-4
-      elsif (n == 2 && q < 0.0001)
-      eps = 1.0e-4
-      elsif (n == 1 && q < 0.001)
-      eps = 1.0e-2
-      else
-      eps = 1.0e-5
-      end
-      s = 10000.0
-      w = 0.0
-      loop do
-      w += s
-      if(s <= eps) then return w end
-      if((qe = 2.0 - p_t(n, w)*2.0 - q) == 0.0) then return w end
-      if(qe < 0.0)
-        w -= s
-        s /= 10.0 #/
-      end
-      end
-      end
-      
-      def pt(q, n)
-        q = q.to_f
-        if(q < 1.0e-5 || q > 1.0 || n < 1)
-        $stderr.printf("Error : Illegal parameter in pt()!\n")
-        return 0.0
+
+        # inverse of t-distribution ([2])
+        # (-\infty, -q/2] + [q/2, \infty)
+        def ptsub(q, n)
+          q = q.to_f
+          if n == 1 && 0.001 < q && q < 0.01
+            eps = 1.0e-4
+          elsif n == 2 && q < 0.0001
+            eps = 1.0e-4
+          elsif n == 1 && q < 0.001
+            eps = 1.0e-2
+          else
+            eps = 1.0e-5
+          end
+          s = 10_000.0
+          w = 0.0
+          loop do
+            w += s
+            return w if (s <= eps)
+            if ((qe = 2.0 - p_t(n, w) * 2.0 - q) == 0.0) then return w end
+            if qe < 0.0
+              w -= s
+              s /= 10.0 # /
+            end
+          end
         end
-        
-        if(n <= 5) then return ptsub(q, n) end
-        if(q <= 5.0e-3 && n <= 13) then return ptsub(q, n) end
-        
-        f1 = 4.0 * (f = n.to_f)
-        f5 = (f4 = (f3 = (f2 = f * f) * f) * f) * f
-        f2 *= 96.0
-        f3 *= 384.0
-        f4 *= 92160.0
-        f5 *= 368640.0
-        u = Normal.p_value(1.0 - q / 2.0)
-        
-        w0 = (u2 = u * u) * u
-        w1 = w0 * u2
-        w2 = w1 * u2
-        w3 = w2 * u2
-        w4 = w3 * u2
-        w = (w0 + u) / f1
-        w += (5.0 * w1 + 16.0 * w0 + 3.0 * u) / f2
-        w += (3.0 * w2 + 19.0 * w1 + 17.0 * w0 - 15.0 * u) / f3
-        w += (79.0 * w3 + 776.0 * w2 + 1482.0 * w1 - 1920.0 * w0 - 9450.0 * u) / f4
-        w += (27.0 * w4 + 339.0 * w3 + 930.0 * w2 - 1782.0 * w1 - 765.0 * w0 + 17955.0 * u) / f5
-        u + w
-      end
-      
-      # Returns the P-value of tdist().
-      def p_value(y,n)
-        if y > 0.5
-          pt(2.0 - y*2.0, n)
-        else
-          - pt(y*2.0, n)
+
+        def pt(q, n)
+          q = q.to_f
+          if q < 1.0e-5 || q > 1.0 || n < 1
+            $stderr.printf("Error : Illegal parameter in pt()!\n")
+            return 0.0
+          end
+
+          return ptsub(q, n) if (n <= 5)
+          return ptsub(q, n) if q <= 5.0e-3 && n <= 13
+
+          f1 = 4.0 * (f = n.to_f)
+          f5 = (f4 = (f3 = (f2 = f * f) * f) * f) * f
+          f2 *= 96.0
+          f3 *= 384.0
+          f4 *= 92_160.0
+          f5 *= 368_640.0
+          u = Normal.p_value(1.0 - q / 2.0)
+
+          w0 = (u2 = u * u) * u
+          w1 = w0 * u2
+          w2 = w1 * u2
+          w3 = w2 * u2
+          w4 = w3 * u2
+          w = (w0 + u) / f1
+          w += (5.0 * w1 + 16.0 * w0 + 3.0 * u) / f2
+          w += (3.0 * w2 + 19.0 * w1 + 17.0 * w0 - 15.0 * u) / f3
+          w += (79.0 * w3 + 776.0 * w2 + 1482.0 * w1 - 1920.0 * w0 - 9450.0 * u) / f4
+          w += (27.0 * w4 + 339.0 * w3 + 930.0 * w2 - 1782.0 * w1 - 765.0 * w0 + 17_955.0 * u) / f5
+          u + w
         end
+
+        # Returns the P-value of tdist().
+        def quantile(y, n)
+          if y > 0.5
+            pt(2.0 - y * 2.0, n)
+          else
+            - pt(y * 2.0, n)
+          end
+        end
+
+        alias_method :p_value, :quantile
       end
-      
-      
     end
   end
 end
-end