rubystats 0.2.6 → 0.3.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 2789811064d35c08bdf8aa20530b392515d065f6
-  data.tar.gz: b148705e2926210b822f42af9e2b51eddedce116
+  metadata.gz: 594c482d4bcbf6954516475851e5d8361eb171e6
+  data.tar.gz: 89bb13f0241a4a42439099c37d4f2500f64b8519
 SHA512:
-  metadata.gz: 817f2c326fbf480121f3f29f909ea04634cdf404240e17c1517f70443d4033b0dd5853974c3889e1facaa801c951361d5f36a8775fe65ee3e553c551b5685682
-  data.tar.gz: e2bc90eed10e16455dbb2721e3d101dd543b0ff2bf7cc4ee255ea540788770ea4ab98290e7169b246a5daa49cbceca7080732da5b8e01746c079581fa558bb0e
+  metadata.gz: 34a76aa78895d6fc605660d72b8e7602c1dd85150132b1bef2969c438cac22c1c91425cf1c3599b3202a43bc5a644444c31e30d9d181c8894cdfa2a70755da89
+  data.tar.gz: 12836502065954197f8c097060794f968d5845e9e9460c6ce175b91df04a569050f26a69855bee7803136661774c0aa39921aff2fe57f89b95de53ef4089782e

data/.travis.yml

@@ -1,6 +1,8 @@
 sudo: false
 cache: bundler
 language: ruby
+before_install:
+  - gem install bundler
 before_script:
   - 'echo ''gem: --no-ri --no-rdoc'' > ~/.gemrc' # skip installing docs for gems
 script: 'bundle exec rake test'

data/README.rdoc

@@ -1,6 +1,6 @@
 = Rubystats
 
-* http://rubyforge.org/projects/rubystats/
+* https://github.com/phillbaker/rubystats
 
 == DESCRIPTION:
 
@@ -37,19 +37,30 @@
 This is beta-quality software. It works well according to my tests, but the API may change and other features may be added.
 
 == FEATURES:
-Classes for distributions:
+Classes for continuous distributions:
 
-* Normal
-* Binomial
 * Beta
+* Cauchy
 * Exponential
+* Gamma
+* Lognormal
+* Multivariate Normal
+* Normal
+* Student t
+* Uniform
+* Weibull
+
+Classes for discrete distributions:
+
+* Binomial
+* Poisson
 
 Also includes Fisher's Exact Test
 
 == SYNOPSIS:
 === Example: normal distribution with mean of 10 and standard deviation of 2
 
- norm = Rubystats::NormalDistribution.new(10, 2)
+ norm = Rubystats::NormalDistribution.new(10.0, 2.0)
  cdf = norm.cdf(11)
  pdf = norm.pdf(11)
  puts "CDF(11): #{cdf}"
@@ -57,7 +68,7 @@ Also includes Fisher's Exact Test
 
 Output:
  CDF(11): 0.691462461274013
- PDF(11): 0.0733813315868699
+ PDF(11): 0.17603266338214973
 
 === Example: get some random numbers from a normal distribution
 

data/examples/uniform.rb

@@ -0,0 +1,14 @@
+$:.unshift File.join(File.dirname(__FILE__), "..", "lib")
+require 'rubystats/uniform_distribution'
+
+#uniform distribution with lower and upper bound of 0.0 and 1.0
+unif = Rubystats::UniformDistribution.new(1.0, 6.0)
+cdf = unif.cdf(2.5)
+pdf = unif.pdf(2.5)
+puts "CDF(2.5): #{cdf}"
+puts "PDF(2.5): #{pdf}"
+
+puts "Random numbers from the uniform distribution:"
+10.times do 
+  puts unif.rng
+end

data/lib/rubystats.rb

@@ -1,8 +1,16 @@
 require 'rubystats/normal_distribution'
 require 'rubystats/binomial_distribution'
+require 'rubystats/poisson_distribution'
 require 'rubystats/beta_distribution'
 require 'rubystats/fishers_exact_test'
 require 'rubystats/exponential_distribution'
+require 'rubystats/uniform_distribution'
+require 'rubystats/lognormal_distribution'
+require 'rubystats/student_t_distribution'
+require 'rubystats/weibull_distribution'
+require 'rubystats/cauchy_distribution'
+require 'rubystats/gamma_distribution'
+require 'rubystats/multivariate_normal_distribution'
 require 'rubystats/version'
 
 module Rubystats
@@ -10,6 +18,27 @@ end
 
 NormalDistribution = Rubystats::NormalDistribution
 BinomialDistribution = Rubystats::BinomialDistribution
+PoissonDistribution = Rubystats::PoissonDistribution
 BetaDistribution = Rubystats::BetaDistribution
 FishersExactTest = Rubystats::FishersExactTest
 ExponentialDistribution = Rubystats::ExponentialDistribution
+UniformDistribution = Rubystats::UniformDistribution
+LognormalDistribution = Rubystats::LognormalDistribution
+StudentTDistribution = Rubystats::StudentTDistribution
+WeibullDistribution = Rubystats::WeibullDistribution
+CauchyDistribution = Rubystats::CauchyDistribution
+GammaDistribution = Rubystats::GammaDistribution
+MultivariateNormalDistribution = Rubystats::MultivariateNormalDistribution
+
+#short-hand notation
+Normal = Rubystats::NormalDistribution
+Binomial = Rubystats::BinomialDistribution
+Poisson = Rubystats::PoissonDistribution
+Beta = Rubystats::BetaDistribution
+Exponential = Rubystats::ExponentialDistribution
+Uniform = Rubystats::UniformDistribution
+Lognormal = Rubystats::LognormalDistribution
+Weibull = Rubystats::WeibullDistribution
+Cauchy = Rubystats::CauchyDistribution
+Gamma = Rubystats::GammaDistribution
+MultivariateNormal = Rubystats::MultivariateNormalDistribution

data/lib/rubystats/beta_distribution.rb

@@ -85,5 +85,9 @@ module Rubystats
       end
     end
 
+    def rng
+      self.icdf(rand)
+    end
+	
   end
 end

data/lib/rubystats/binomial_distribution.rb

@@ -9,6 +9,7 @@ module Rubystats
     include Rubystats::NumericalConstants
     include Rubystats::SpecialMath
     include Rubystats::ExtraMath
+    include Rubystats::MakeDiscrete
 
     attr_reader :p, :n
     attr_writer :p, :n
@@ -18,11 +19,11 @@ module Rubystats
       if trials <= 0
         raise ArgumentError.new("Error: trials must be greater than 0")
       end
-      @n = trials
+      @n = trials.to_i
       if prob < 0.0 || prob > 1.0
         raise ArgumentError.new("prob must be between 0 and 1")
       end
-      @p = prob
+      @p = prob.to_f
     end
 
     #returns the number of trials
@@ -45,79 +46,20 @@ module Rubystats
       @n * @p * (1.0 - @p)
     end
 
+    # Private methods below
+
+    private
+
     # Probability density function of a binomial distribution (equivalent
     # to R dbinom function).
     # _x should be an integer
     # returns the probability that a stochastic variable x has the value _x,
     # i.e. P(x = _x)
-    def pdf(_x)
-      if _x.class == Array
-        pdf_vals = []
-        for i in (0 ... _x.length)
-          check_range(_x[i], 0.0, @n)
-          pdf_vals[i] = binomial(@n, _x[i]) * (1-@p)**(@n-_x[i])
-        end
-        return pdf_vals
-      else
-        check_range(_x, 0.0, @n)
-        return binomial(@n, _x) * @p**_x * (1-@p)**(@n-_x)
-      end
-    end
-
-    # Cumulative binomial distribution function (equivalent to R pbinom function).
-    # _x should be integer-valued and can be single integer or array of integers
-    # returns single value or array containing probability that a stochastic 
-    # variable x is less then X, i.e. P(x < _x).
-    def cdf(_x)
-      if _x.class == Array
-        pdf_vals = []
-        for i in (0 ..._x.length)
-          pdf_vals[i] = get_cdf(_x[i])
-        end
-        return pdf_vals
-      else
-        return get_cdf(_x)
-      end
-    end
-
-    # Inverse of the cumulative binomial distribution function 
-    # (equivalent to R qbinom function).
-    # returns the value X for which P(x < _x).
-    def get_icdf(prob)
-      if prob.class == Array
-        inv_vals = []
-        for i in (0 ...prob.length)
-          check_range(prob[i])
-          inv_vals[i] = (find_root(prob[i], @n/2, 0.0, @n)).floor
-        end
-        return inv_vals
-      else
-        check_range(prob)
-        return (find_root(prob, @n/2, 0.0, @n)).floor
-      end
-    end
-
-    # Wrapper for binomial RNG function (equivalent to R rbinom function).
-    # returns random deviate given trials and p
-    def rng(num_vals = 1)
-      if num_vals < 1
-        raise "Error num_vals must be greater than or equal to 1"
-      end
-      if num_vals == 1
-        return get_rng
-      else
-        rand_vals = []
-        for i in (0 ...num_vals)
-          rand_vals[i] = get_rng
-        end
-        return rand_vals
-      end
+    def get_pdf(x)
+      check_range(x, 0, @n)
+      binomial(@n, x) * @p**x * (1-@p)**(@n-x)
     end
 
-    # Private methods below
-
-    private
-
     # Private shared function for getting cumulant for particular x
     # param _x should be integer-valued
     # returns the probability that a stochastic variable x is less than _x
@@ -128,71 +70,40 @@ module Rubystats
       for i in (0 .. _x) 
         sum = sum + pdf(i)
       end
-      return sum
+      sum
     end
 
-    # Private binomial RNG function
-    # Original version of this function from Press et al.
-    #
-    # see http://www.library.cornell.edu/nr/bookcpdf/c7-3.pdf
-    #
-    # Changed parts having to do with generating a uniformly distributed
-    # number in the 0 to 1 range.  Also using instance variables, instead
-    # of supplying function with p and n values.  Finally calling port
-    # of JSci's log gamma routine instead of Press et al.
-    #
-    # There are enough non-trivial changes to this function that the
-    # port conforms to the Press et al. copyright.
-    def get_rng
-      nold = -1
-      pold = -1
-      p = (if @p <= 0.5 then @p else 1.0 - @p end)
-      am = @n * p
-      if @n < 25
-        bnl = 0.0
-        (1...@n).each do
-          if  Kernel.rand < p 
-            bnl = bnl.next
-          end
-        end
-      elsif am < 1.0
-        g = Math.exp(-am)
-        t = 1.0
-        for j in (0 ... @n)
-          t = t * Kernel.rand
-          break if t < g
-        end
-        bnl = (if j <= @n then j else @n end)
-      else
-        if n != nold
-          en = @n
-          oldg = log_gamma(en + 1.0)
-          nold = n
-        end
-        if p != pold
-          pc = 1.0 - p
-          plog = Math.log(p)
-          pclog = Math.log(pc)
-          pold = p
-        end
-        sq = Math.sqrt(2.0 * am * pc)
-        until Kernel.rand <= t do
-          until (em >= 0.0 || em < (en + 1.0)) do
-            angle = Pi * Kernel.rand
-            y = Math.tan(angle)
-            em = sq * y + am
-          end
-          em = em.floor
-          t = 1.2 * sq * (1.0 + y * y) * 
-          Math.exp(oldg - log_gamma(em + 1.0) - 
-          log_gamma(en - em + 1.0) + em * plog + (en - em) * pclog)
-        end
-        bnl = em
-      end
-      if p != @p
-        bnl = @n - bnl
-      end
-      return bnl
+    # Inverse of the cumulative binomial distribution function     
+    # returns the value X for which P(x < _x).
+    def get_icdf(prob)
+      check_range(prob)
+      sum = 0.0
+      k = 0
+      until prob <= sum 
+        sum += get_pdf(k)
+        k += 1
+      end 
+      k - 1
     end
+
+    # Private binomial RNG function    
+    # Variation of Luc Devroye's "Second Waiting Time Method" 
+    # on page 522 of his text "Non-Uniform Random Variate Generation."
+    # There are faster methods based on acceptance/rejection techniques, 
+    # but they are substantially more complex to implement.
+    def get_rng      
+      p = (@p <= 0.5) ? @p : (1.0 - @p)        
+      log_q = Math.log(1.0 - p)
+      sum = 0.0
+      k = 0
+      loop do
+        sum += Math.log(Kernel.rand) / (@n - k)
+        if (sum < log_q)
+          return (p != @p) ? (@n - k) : k          
+        end
+        k += 1
+      end     
+    end      
+  
   end
 end

data/lib/rubystats/cauchy_distribution.rb

@@ -0,0 +1,50 @@
+require 'rubystats/probability_distribution'
+module Rubystats
+  class CauchyDistribution < Rubystats::ProbabilityDistribution
+    
+    def initialize(location=1.0,scale=1.0) 
+      if scale <= 0.0
+        raise ArgumentError.new("Scale parameter in Cauchy distribution should be greater than zero.")
+      end
+      @location = location.to_f
+      @scale = scale.to_f
+    end
+
+    private
+
+    def get_mean 
+      Float::NAN
+    end
+
+    def get_variance 
+      Float::NAN
+    end
+
+    # Private method to obtain single PDF value.
+    # x should be greater than 0  
+    # returns the probability that a stochastic variable x has the value X, i.e. P(x=X). 
+    def get_pdf(x) 
+      1.0 / (Math::PI * @scale * (1.0 + ((x - @location) / @scale)**2))
+    end
+
+    # Private method to obtain single CDF value.
+    # param x should be greater than 0    
+    # return the probability that a stochastic variable x is less then X, i.e. P(x<X).
+    def get_cdf(x)
+      (1.0 / Math::PI) * Math.atan((x - @location) / @scale) + 0.5   
+    end
+
+    # Private method to obtain single inverse CDF value.
+    # return the value X for which P(x<X).
+    def get_icdf(p) 
+      check_range(p)
+      @location + @scale * Math.tan(Math::PI * (p - 0.5))
+    end
+
+    # Private method to obtain single RNG value.
+    def get_rng   
+      self.icdf(Kernel.rand)
+    end
+
+  end
+end

data/lib/rubystats/exponential_distribution.rb

@@ -10,11 +10,11 @@ module Rubystats
     include Rubystats::SpecialMath
     include Rubystats::ExtraMath
 
-    def initialize(decay=1) 
+    def initialize(decay=1.0) 
       if decay < 0.0
         raise ArgumentError.new("Decay parameter should be positive.")
       end
-      @rate = decay
+      @rate = decay.to_f
     end
 
     private

data/lib/rubystats/gamma_distribution.rb

@@ -0,0 +1,70 @@
+require 'rubystats/normal_distribution'
+require 'rubystats/probability_distribution'
+module Rubystats
+  class GammaDistribution < Rubystats::ProbabilityDistribution
+    include Rubystats::NumericalConstants
+    include Rubystats::SpecialMath
+   
+    def initialize(shape=1.0, scale=1.0) 
+      if shape <= 0.0 || scale <= 0.0
+        raise ArgumentError.new("Input parameter should be greater than zero.")
+      end
+      @shape = shape.to_f 
+      @scale = scale.to_f 
+    end
+
+    private
+
+    def get_mean 
+      @scale * @shape 
+    end
+
+    def get_variance 
+      @shape * (@scale)**2
+    end
+
+    # Private method to obtain single PDF value.
+    # x should be greater than or equal to 0.0  
+    # returns the probability that a stochastic variable x has the value X, i.e. P(x=X). 
+    def get_pdf(x) 
+      check_range(x, 0.0, MAX_VALUE)
+      1.0 / (Math.gamma(@shape) * (@scale**@shape)) * (x**(@shape-1.0)) * Math.exp(-1.0 * x / @scale)
+    end
+
+    # Private method to obtain single CDF value.
+    # param x should be greater than 0    
+    # return the probability that a stochastic variable x is less then X, i.e. P(x<X).
+    def get_cdf(x)
+      check_range(x,0.0,MAX_VALUE)
+      @scale * incomplete_gamma(@shape, x/@scale) / Math.gamma(@shape)
+    end
+
+    # Private method to obtain single inverse CDF value.
+    # return the value X for which P(x<X).
+    def get_icdf(p) 
+      check_range(p)
+      raise "Inverse CDF for gamma not implemented yet."
+    end
+
+    # Private method to obtain single RNG value.
+    # Generate gamma random variate with 
+    # Marsaglia's squeeze method.
+    def get_rng
+      raise "Gamma RNG not working for shape < 1" if @shape < 1.0
+      norm = Rubystats::NormalDistribution.new(0,1)
+      d = @shape - 1.0 / 3.0
+      c = 1.0 / Math.sqrt(9.0 * d)
+      MAX_ITERATIONS.times do  
+        x = norm.rng
+        v = (1.0 + c * x)**(3.0)
+        next if v <= 0.0
+        u = Kernel.rand
+        if (u < 1.0 - 0.03331 * (x**4)) || (Math.log(u) < 0.5 * x**2 + d * (1.0 - v + Math.log(v)))
+          return (d * v) * @scale   
+        end
+      end 
+      raise "Gamma RNG not converged after max_iterations = #{MAX_ITERATIONS}" 
+    end
+
+  end
+end