distribution 0.1.0

data/lib/distribution/normal.rb

@@ -0,0 +1,36 @@
+require 'distribution/normal/ruby'
+require 'distribution/normal/gsl'
+require 'distribution/normal/statistics2'
+
+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
+  module Normal
+    SHORTHAND='norm'
+    extend Distributable
+    
+    create_distribution_methods
+    
+    ##
+    # :singleton-method: pdf(x)
+    # 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

@@ -0,0 +1,24 @@
+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)}
+        end
+        def cdf(x) # :nodoc:
+          GSL::Cdf::ugaussian_P(x)
+        end
+        def pdf(x) # :nodoc:
+          GSL::Ran::gaussian_pdf(x)
+        end
+        def p_value(qn)
+          GSL::Cdf::ugaussian_Pinv(qn)
+        end
+        def gsl
+        end
+      end
+    end
+  end
+end

data/lib/distribution/normal/ruby.rb

@@ -0,0 +1,99 @@
+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
+              begin
+                x1 = 2.0 * rand - 1.0
+                x2 = 2.0 * rand - 1.0
+                w = x1 * x1 + x2 * x2
+              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
+            else
+              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
+
+          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)
+
+        end
+        # Normal cumulative distribution function (cdf).
+        # 
+        # Returns the integral of  normal distribution 
+        # over (-Infty, z].
+        # 
+        def cdf(z)
+          0.0 if z < -12 
+          1.0 if z > 12
+          0.5 if z == 0.0 
+
+          if z > 0.0
+            e = true
+          else
+            e = false
+            z = -z
+          end
+          z = z.to_f
+          z2 = z * z
+          t = q = z * Math.exp(-0.5 * z2) / SQ2PI
+
+          3.step(199, 2) do |i|
+            prev = q
+            t *= z2 / i
+            q += t
+            if q <= prev
+              return(e ? 0.5 + q : 0.5 - q)
+            end
+          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))
+        end
+      end
+    end
+  end
+end

data/lib/distribution/normal/statistics2.rb

@@ -0,0 +1,14 @@
+module Distribution
+  module Normal
+    module Statistics2_
+      class << self
+        def cdf(x)
+          Statistics2.normaldist(x)
+        end
+        def p_value(pr)
+         Statistics2.pnormaldist(pr)
+        end
+      end
+    end
+  end
+end

data/lib/distribution/normalmultivariate.rb

@@ -0,0 +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]
+
+          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]
+              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]))
+              end
+              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
+      end
+    end
+end

data/lib/distribution/t.rb

@@ -0,0 +1,27 @@
+require 'distribution/t/ruby'
+require 'distribution/t/gsl'
+require 'distribution/t/statistics2'
+module Distribution
+
+    # Calculate statisticals for T Distribution.
+    module T
+      SHORTHAND='f'  
+      extend Distributable
+      create_distribution_methods
+      
+    ##
+    # :singleton-method: pdf(x,k)
+    # 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    
+    
+    ##
+    # :singleton-method: cdf(x,k)
+    # Returns the integral of T distribution 
+    # with +k+ degrees of freedom over [0, +x+]    
+    end
+end

data/lib/distribution/t/gsl.rb

@@ -0,0 +1,29 @@
+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)
+      end
+    end
+  end
+  end
+end

data/lib/distribution/t/ruby.rb

@@ -0,0 +1,105 @@
+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)
+        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 or 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
+      
+      
+      # 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 : Illigal parameter in pt()!\n")
+        return 0.0
+        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)
+        end
+      end
+      
+      
+    end
+  end
+end
+end

data/lib/distribution/t/statistics2.rb

@@ -0,0 +1,28 @@
+require 'rbconfig'
+module Distribution
+  module T
+    module Statistics2_
+      class << self
+      # Return the P-value of the corresponding integral with 
+      # k degrees of freedom
+      def p_value(pr,k)
+        Statistics2.ptdist(k, pr)
+      end
+      
+       
+      # There are some problem on i686 with t on statistics2
+      if !RbConfig::CONFIG['arch']=~/i686/
+        # T cumulative distribution function (cdf).
+        # 
+        # Returns the integral of t-distribution 
+        # with n degrees of freedom over (-Infty, x].
+        #
+        def cdf(x,k)
+          Statistics2.tdist(k,x)
+        end
+      end
+      
+      end
+    end
+  end
+end