distribution 0.7.3 → 0.8.0

data/lib/distribution/math_extension/log_utilities.rb

@@ -15,62 +15,60 @@ module Distribution
       C8 =  1.quo(9)
       C9 = -1.quo(10)
       class << self
-
         # gsl_log1p from GSL-1.9 sys/log1p.c
         # log for very small x
-        def log1p x
+        def log1p(x)
           # in C, this is volatile double y.
           # Not sure how to reproduce that in Ruby.
-          y = 1+x
-          Math.log(y) - ((y-1)-x).quo(y) # cancel errors with IEEE arithmetic
+          y = 1 + x
+          Math.log(y) - ((y - 1) - x).quo(y) # cancel errors with IEEE arithmetic
         end
 
         # \log(1+x) for x > -1
         # gsl_sf_log_1plusx_e
         def log_1plusx(x, with_error = false)
-          raise(ArgumentError, "Range error: x must be > -1") if x <= -1
+          fail(ArgumentError, 'Range error: x must be > -1') if x <= -1
 
           if x.abs < Math::ROOT6_FLOAT_EPSILON
-            result = x * (1.0 + x * (C1 + x*(C2 + x*(C3 + x*(C4 + x*begin
-                       C5 + x*(C6 + x*(C7 + x*(C8 + x*C9))) # formerly t = this
+            result = x * (1.0 + x * (C1 + x * (C2 + x * (C3 + x * (C4 + x * begin
+              C5 + x * (C6 + x * (C7 + x * (C8 + x * C9))) # formerly t = this
             end)))))
             return with_error ? [result, Float::EPSILON * result.abs] : result
           elsif x.abs < 0.5
-            c = ChebyshevSeries.evaluate(:lopx, (8*x + 1).quo(2*x+4), with_error)
-            return with_error ? [x * c.first, x * c.last] : x*c
+            c = ChebyshevSeries.evaluate(:lopx, (8 * x + 1).quo(2 * x + 4), with_error)
+            return with_error ? [x * c.first, x * c.last] : x * c
           else
-            result = Math.log(1+x)
-            return with_error ? [result, Float::EPSILON*result.abs] : result
+            result = Math.log(1 + x)
+            return with_error ? [result, Float::EPSILON * result.abs] : result
           end
         end
 
-
         # \log(1+x)-x for x > -1
         # gsl_sf_log_1plusx_mx_e
-        def log_1plusx_minusx x, with_error = false
-          raise(ArgumentError, "Range error: x must be > -1") if x <= -1
+        def log_1plusx_minusx(x, with_error = false)
+          fail(ArgumentError, 'Range error: x must be > -1') if x <= -1
 
           if x.abs < Math::ROOT5_FLOAT_EPSILON
-            result = x*x * (C1 + x*(C2 + x*(C3 + x*(C4 + x*begin
-                       C5 + x*(C6 + x*(C7 + x*(C8 + x*C9))) # formerly t = this
+            result = x * x * (C1 + x * (C2 + x * (C3 + x * (C4 + x * begin
+              C5 + x * (C6 + x * (C7 + x * (C8 + x * C9))) # formerly t = this
             end))))
             return with_error ? [result, Float::EPSILON * result.abs] : result
           elsif x.abs < 0.5
-            c = ChebyshevSeries.evaluate(:lopxmx, (8*x + 1).quo(2*x+4), with_error)
-            return with_error ? [x*x * c.first, x*x * c.last] : x*x*c
+            c = ChebyshevSeries.evaluate(:lopxmx, (8 * x + 1).quo(2 * x + 4), with_error)
+            return with_error ? [x * x * c.first, x * x * c.last] : x * x * c
           else
-            lterm = Math.log(1.0+x)
+            lterm = Math.log(1.0 + x)
             error = Float::EPSILON * (lterm.abs + x.abs) if with_error
             result = lterm - x
             return with_error ? [result, error] : result
           end
         end
 
-      protected
+        protected
 
         # Abstracted from other log helper functions in GSL-1.9.
-        def x_less_than_root_epsilon x, with_error
-          result  = square_x ? x*x : x
+        def x_less_than_root_epsilon(x, with_error)
+          result  = square_x ? x * x : x
 
           with_error ? [result, Float::EPSILON * result.abs] : result
         end

data/lib/distribution/normal.rb

@@ -4,34 +4,32 @@ require 'distribution/normal/statistics2'
 require 'distribution/normal/java'
 
 module Distribution
-  # From Wikipedia: 
-  #   Continuous probability distribution that is often used as 
-  #   a first approximation to describe real-valued random variables 
-  #   that tend to cluster around a single mean value. 
-  #   The graph of the associated probability density function is  “bell”-shaped
+  # From Wikipedia:
+  #   Continuous probability distribution that is often used as
+  #   a first approximation to describe real-valued random variables
+  #   that tend to cluster around a single mean value.
+  #   The graph of the associated probability density function is "bell-shaped.
   module Normal
-    SHORTHAND='norm'
+    SHORTHAND = 'norm'
     extend Distributable
-    
+
     create_distribution_methods
-    
+
     ##
     # :singleton-method: pdf(x)
-    # Returns PDF of Normal distribution 
+    # Returns PDF of Normal distribution
 
     ##
     # :singleton-method: p_value(qn)
     # Return the P-value of the corresponding integral +qn+
-    
+
     ##
     # :singleton-method: cdf(x)
     # Returns the integral of Normal distribution over [0, +x+]
-    
+
     ##
     # :singleton-method: rng
     # Returns a lambda which returns a random number from
     # X ~ N(0,1)
-
-    
   end
 end

data/lib/distribution/normal/gsl.rb

@@ -2,22 +2,25 @@ module Distribution
   module Normal
     module GSL_
       class << self
-        def rng(mean=0,sigma=1,seed=nil)
-          seed||=rand(10e8)
-          rng=GSL::Rng.alloc(GSL::Rng::MT19937,seed)
-          lambda { mean+rng.gaussian(sigma)}
+        def rng(mean = 0, sigma = 1, seed = nil)
+          seed ||= rand(10e8)
+          rng = GSL::Rng.alloc(GSL::Rng::MT19937, seed)
+          -> { mean + rng.gaussian(sigma) }
         end
+
         def cdf(x) # :nodoc:
-          GSL::Cdf::ugaussian_P(x)
+          GSL::Cdf.ugaussian_P(x)
         end
+
         def pdf(x) # :nodoc:
-          GSL::Ran::gaussian_pdf(x)
+          GSL::Ran.gaussian_pdf(x)
         end
-        def p_value(qn)
-          GSL::Cdf::ugaussian_Pinv(qn)
-        end
-        def gsl
+
+        def quantile(qn)
+          GSL::Cdf.ugaussian_Pinv(qn)
         end
+
+        alias_method :p_value, :quantile
       end
     end
   end

data/lib/distribution/normal/java.rb

@@ -5,33 +5,34 @@ module Distribution
       class << self
         #==
         # Generate random variables from the provided distribution
-        def rng(mean=0,sigma=1,seed=nil)
+        def rng(mean = 0, sigma = 1, _seed = nil)
           dist = NormalDistributionImpl.new(mean, sigma)
-          lambda { dist.sample }
+          -> { dist.sample }
         end
-        
+
         #==
-        # Get the inverse cumulative density function (p-value) for qn
-        def p_value(qn)
+        # Return the probability density function at x
+        def pdf(x)
           dist = NormalDistributionImpl.new
-          dist.inverseCumulativeProbability(qn)
+          dist.density(x)
         end
-        
+
         #==
         # Return the cumulative density function at x
         def cdf(x)
           dist = NormalDistributionImpl.new
           dist.cumulativeProbability(x)
         end
-        
+
         #==
-        # Return the probability density function at x
-        def pdf(x)
+        # Get the inverse cumulative density function (p-value) for qn
+        def quantile(qn)
           dist = NormalDistributionImpl.new
-          dist.density(x)
+          dist.inverseCumulativeProbability(qn)
         end
-      
+
+        alias_method :p_value, :quantile
       end
     end
   end
-end
+end

data/lib/distribution/normal/ruby.rb

@@ -1,71 +1,64 @@
-module Distribution  
+module Distribution
   module Normal
     module Ruby_
       class << self
-        
-        # random number within a gaussian distribution X ~ N(0,1)
-        def rngu
-          rng(0,1,nil)
-        end
-        # Return a proc which return a random number within a 
-        # gaussian distribution X ~ N(+mean+,+sigma+^2)
-        # +seed+ feed the  
-        # == Reference:
-        # * http://www.taygeta.com/random/gaussian.html
-        def rng(mean=0,sigma=1,seed=nil)
-          returned,y1,y2=0,0,0
-          lambda {
-            if returned==0
+        # Return a Proc object which returns a random number drawn 
+        # from the normal distribution with mean +mean+ and
+        # standard deviation +sigma+, i.e. from N(+mean+,+sigma+^2).
+        #
+        # == Arguments
+        #   * +mean+  - mean of the normal distribution
+        #   * +sigma+ - standard deviation, a strictly positive number
+        #   * +seed+  - seed, an integer value to set the initial state
+        #
+        # == Reference
+        #   * http://www.taygeta.com/random/gaussian.html
+        #
+        def rng(mean = 0, sigma = 1, seed = nil)
+          seed = Random.new_seed if seed.nil?
+          r = Random.new(seed)
+          returned = 0
+          y1 = 0
+          y2 = 0
+          lambda do
+            if returned == 0
               begin
-                x1 = 2.0 * rand - 1.0
-                x2 = 2.0 * rand - 1.0
+                x1 = 2.0 * r.rand - 1.0
+                x2 = 2.0 * r.rand - 1.0
                 w = x1 * x1 + x2 * x2
-              end while ( w >= 1.0 )
-              w = Math::sqrt( (-2.0 * Math::log( w ) ) / w )
+              end while (w >= 1.0)
+              w = Math.sqrt((-2.0 * Math.log(w)) / w)
               y1 = x1 * w
               y2 = x2 * w
-              returned=1
-              y1*sigma + mean
+              returned = 1
+              y1 * sigma + mean
             else
-              returned=0
+              returned = 0
               y2 * sigma + mean
             end
-          }
-        
-        end
-        # Return the inverse CDF or P-value of the corresponding integral
-        def p_value(qn)
-          b = [1.570796288, 0.03706987906, -0.8364353589e-3,
-          -0.2250947176e-3, 0.6841218299e-5, 0.5824238515e-5,
-          -0.104527497e-5, 0.8360937017e-7, -0.3231081277e-8,
-          0.3657763036e-10, 0.6936233982e-12]
-
-          if(qn < 0.0 || 1.0 < qn)
-          $stderr.printf("Error : qn <= 0 or qn >= 1  in pnorm()!\n")
-          return 0.0;
           end
-          qn == 0.5 and return 0.0
+        end
 
-          w1 = qn
-          qn > 0.5 and w1 = 1.0 - w1
-          w3 = -Math.log(4.0 * w1 * (1.0 - w1))
-          w1 = b[0]
-          1.upto 10 do |i|
-          w1 += b[i] * w3**i;
-          end
-          qn > 0.5 and return Math.sqrt(w1 * w3)
-          -Math.sqrt(w1 * w3)
+        # random number within a gaussian distribution X ~ N(0,1)
+        def rngu
+          rng(0, 1, nil)
+        end
 
+        # Normal probability density function (pdf)
+        # With x=0 and sigma=1
+        def pdf(x)
+          (1.0 / SQ2PI) * Math.exp(-(x**2 / 2.0))
         end
+
         # Normal cumulative distribution function (cdf).
-        # 
-        # Returns the integral of  normal distribution 
+        #
+        # Returns the integral of  normal distribution
         # over (-Infty, z].
-        # 
+        #
         def cdf(z)
-          return 0.0 if z < -12 
+          return 0.0 if z < -12
           return 1.0 if z > 12
-          return 0.5 if z == 0.0 
+          return 0.5 if z == 0.0
 
           if z > 0.0
             e = true
@@ -81,18 +74,35 @@ module Distribution
             prev = q
             t *= z2 / i
             q += t
-            if q <= prev
-              return(e ? 0.5 + q : 0.5 - q)
-            end
+            return(e ? 0.5 + q : 0.5 - q) if q <= prev
           end
           e ? 1.0 : 0.0
         end
-        
-        # Normal probability density function (pdf)
-        # With x=0 and sigma=1
-        def pdf(x)
-          (1.0 / SQ2PI)*Math::exp(-(x**2/2.0))
+
+        # Return the inverse CDF or P-value of the corresponding integral
+        def quantile(qn)
+          b = [1.570796288, 0.03706987906, -0.8364353589e-3,
+               -0.2250947176e-3, 0.6841218299e-5, 0.5824238515e-5,
+               -0.104527497e-5, 0.8360937017e-7, -0.3231081277e-8,
+               0.3657763036e-10, 0.6936233982e-12]
+
+          if qn < 0.0 || 1.0 < qn
+            $stderr.printf("Error : qn <= 0 or qn >= 1  in pnorm()!\n")
+            return 0.0
+          end
+          qn == 0.5 and return 0.0
+
+          w1 = qn
+          w3 = -Math.log(4.0 * w1 * (1.0 - w1))
+          w1 = b[0]
+          1.upto 10 do |i|
+            w1 += b[i] * w3**i
+          end
+          qn > 0.5 and return Math.sqrt(w1 * w3)
+          -Math.sqrt(w1 * w3)
         end
+
+        alias_method :p_value, :quantile
       end
     end
   end

data/lib/distribution/normal/statistics2.rb

@@ -5,9 +5,12 @@ module Distribution
         def cdf(x)
           Statistics2.normaldist(x)
         end
-        def p_value(pr)
-         Statistics2.pnormaldist(pr)
+
+        def quantile(pr)
+          Statistics2.pnormaldist(pr)
         end
+
+        alias_method :p_value, :quantile
       end
     end
   end

data/lib/distribution/normalmultivariate.rb

@@ -1,73 +1,73 @@
 module Distribution
-    # Calculate cdf and inverse cdf for Multivariate Distribution.
-    module NormalMultivariate
-      class << self
-        # Returns multivariate cdf distribution
-        # * a is the array of lower values
-        # * b is the array of higher values
-        # * s is an symmetric positive definite covariance matrix
-        def cdf(aa,bb,sigma, epsilon=0.0001, alpha=2.5, max_iterations=100) # :nodoc:
-          raise "Doesn't work yet"
-          a=[nil]+aa
-          b=[nil]+bb
-          m=aa.size
-          sigma=sigma.to_gsl if sigma.respond_to? :to_gsl
-          
-          cc=GSL::Linalg::Cholesky.decomp(sigma)
-          c=cc.lower
-          intsum=0
-          varsum=0
-          n=0
-          d=Array.new(m+1,nil)
-          e=Array.new(m+1,nil)
-          f=Array.new(m+1,nil)
-          (1..m).each {|i|
-            d[i]=0.0 if a[i].nil?
-            e[i]=1.0 if b[i].nil?
-          }
-          d[1]=uPhi(a[1].quo( c[0,0])) unless d[1]==0
-          e[1]=uPhi(b[1].quo( c[0,0])) unless e[1]==1
-          f[1]=e[1]-d[1]
+  # Calculate cdf and inverse cdf for Multivariate Distribution.
+  module NormalMultivariate
+    class << self
+      # Returns multivariate cdf distribution
+      # * a is the array of lower values
+      # * b is the array of higher values
+      # * s is an symmetric positive definite covariance matrix
+      def cdf(aa, bb, sigma, epsilon = 0.0001, alpha = 2.5, max_iterations = 100) # :nodoc:
+        fail "Doesn't work yet"
+        a = [nil] + aa
+        b = [nil] + bb
+        m = aa.size
+        sigma = sigma.to_gsl if sigma.respond_to? :to_gsl
 
-          error=1000
-          begin 
-            w=(m+1).times.collect {|i| rand*epsilon}
-            y=[]
+        cc = GSL::Linalg::Cholesky.decomp(sigma)
+        c = cc.lower
+        intsum = 0
+        varsum = 0
+        n = 0
+        d = Array.new(m + 1, nil)
+        e = Array.new(m + 1, nil)
+        f = Array.new(m + 1, nil)
+        (1..m).each do|i|
+          d[i] = 0.0 if a[i].nil?
+          e[i] = 1.0 if b[i].nil?
+        end
+        d[1] = uPhi(a[1].quo(c[0, 0])) unless d[1] == 0
+        e[1] = uPhi(b[1].quo(c[0, 0])) unless e[1] == 1
+        f[1] = e[1] - d[1]
+
+        error = 1000
+        begin
+            w = (m + 1).times.collect { |_i| rand * epsilon }
+            y = []
             (2..m).each do |i|
-              y[i-1]=iPhi(d[i-1] + w[i-1] * (e[i-1] - d[i-1]))
-              sumc=0
-              (1..(i-1)).each do |j|
-                sumc+=c[i-1, j-1]*y[j]
+              y[i - 1] = iPhi(d[i - 1] + w[i - 1] * (e[i - 1] - d[i - 1]))
+              sumc = 0
+              (1..(i - 1)).each do |j|
+                sumc += c[i - 1, j - 1] * y[j]
               end
-              
-              if a[i]!=nil
-                d[i]=uPhi((a[i]-sumc).quo(c[i-1,i-1]))
-              end
-             # puts "sumc:#{sumc}"
-              
-              if b[i]!=nil
-                #puts "e[#{i}] :#{c[i-1,i-1]}"
-                e[i]=uPhi((b[i]-sumc).quo(c[i-1, i-1]))
+
+              d[i] = uPhi((a[i] - sumc).quo(c[i - 1, i - 1])) unless a[i].nil?
+              # puts "sumc:#{sumc}"
+
+              unless b[i].nil?
+                # puts "e[#{i}] :#{c[i-1,i-1]}"
+                e[i] = uPhi((b[i] - sumc).quo(c[i - 1, i - 1]))
               end
-              f[i]=(e[i]-d[i])*f[i-1]
+              f[i] = (e[i] - d[i]) * f[i - 1]
             end
-            intsum+=intsum+f[m]
-            varsum=varsum+f[m]**2
-            n+=1
-            error=alpha*Math::sqrt((varsum.quo(n) - (intsum.quo(n))**2).quo(n))
-            end while(error>epsilon and n<max_iterations)
-          
-            f=intsum.quo(n)
-          #p intsum
-          #puts "f:#{f}, n:#{n}, error:#{error}"
-          f
-        end
-        def iPhi(pr)
-          Distribution::Normal.p_value(pr)
-        end
-        def uPhi(x)
-          Distribution::Normal.cdf(x)
-        end
+            intsum += intsum + f[m]
+            varsum += f[m]**2
+            n += 1
+            error = alpha * Math.sqrt((varsum.quo(n) - (intsum.quo(n))**2).quo(n))
+          end while(error > epsilon && n < max_iterations)
+
+        f = intsum.quo(n)
+        # p intsum
+        # puts "f:#{f}, n:#{n}, error:#{error}"
+        f
+      end
+
+      def iPhi(pr)
+        Distribution::Normal.p_value(pr)
+      end
+
+      def uPhi(x)
+        Distribution::Normal.cdf(x)
       end
     end
+  end
 end