rubystats 0.2.6 → 0.4.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 2789811064d35c08bdf8aa20530b392515d065f6
-  data.tar.gz: b148705e2926210b822f42af9e2b51eddedce116
+  metadata.gz: b5ce2923f406326fbac5468f2d90b3dd65ac7260
+  data.tar.gz: 71e668ad6712572d8e33145b2f6689bab25a9d03
 SHA512:
-  metadata.gz: 817f2c326fbf480121f3f29f909ea04634cdf404240e17c1517f70443d4033b0dd5853974c3889e1facaa801c951361d5f36a8775fe65ee3e553c551b5685682
-  data.tar.gz: e2bc90eed10e16455dbb2721e3d101dd543b0ff2bf7cc4ee255ea540788770ea4ab98290e7169b246a5daa49cbceca7080732da5b8e01746c079581fa558bb0e
+  metadata.gz: 4f56dbac4cb7ca98f9fea5932e22611d2a3631ba23316a90a25d26a30f3bf8005ab98caf2a7eb8efb6aa1ae8c161b6800c05af33ddee8e17950c8f8dc28b5e40
+  data.tar.gz: 4c9e4e0c71ce1aa6e5ad903a69bfe5c7051e6c3cd1f479d5708ce8e20ce4040cf52f009ce81bb272d7805000cd3d27c40bdb67caa84453a5e2f642074c123a12

data/.github/workflows/test.yml

@@ -0,0 +1,21 @@
+on: [push, pull_request]
+
+jobs:
+  test:
+    runs-on: ubuntu-latest
+    strategy:
+      matrix:
+        ruby-version: ['2.7', '3.0', '3.1', '3.2']
+        gemfile:
+          - Gemfile
+    env:
+      BUNDLE_GEMFILE: ${{ github.workspace }}/${{ matrix.gemfile }}
+    steps:
+    - uses: actions/checkout@v3
+    - name: Set up Ruby
+      uses: ruby/setup-ruby@v1
+      with:
+        ruby-version: ${{ matrix.ruby-version }}
+        bundler-cache: true # runs 'bundle install' and caches installed gems automatically
+    - name: Run tests
+      run: bundle exec rake

data/History.txt

@@ -1,3 +1,34 @@
+=== 0.3.0 / 2023-04-03
+* Add support for ruby 3.1
+
+=== 0.3.0 / 2017-12-01
+* Uniform distribution
+* added gamma distribution (mean, variance, pdf, cdf, rng)
+* implemented multivariate normal distribution (mean,pdf,rng)
+* cleaned up the code for the binomial distribution and created a module for discrete probability distributions
+* implementation of poisson distribution (mean,variance,pdf,cdf,icdf,rng)
+* fixed rng in Binomial and Poisson and added tests for their rng functions
+* rewrote factorial function because of error with too many stack levels
+* added student t distribution (mean, variance, pdf, rng)
+* added weibull implementation (mean,pdf,cdf,icdf,rng)
+* fix to prevent integer calculations when distributions are initialized (#10)
+* Update beta_distribution.rb
+* Added rng for beta distribution
+* Corrected PDF calculation in README.rdoc
+
+=== 0.2.6 / 2017-07-23
+* Preserve the old API by setting constants manually
+
+=== 0.2.5 / 2016-07-08
+* refactoring to reduce warnings
+* reactivate and fix test for normal distribution
+* Use attr_reader to avoid initialization warnings.
+* add test for normal distributed random numbers
+
+=== 0.2.4 / 2016-01-31
+* raise error when normal initialised with bad sigma
+* changes for CI tests
+
 === 0.2.3 / 2008-07-06
 * Fixing bug #21100 - problem with Beta distribution calculations when p and q values are small.
 * Minor code cleanup for readability in a few places.

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/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

data/lib/rubystats/lognormal_distribution.rb

@@ -0,0 +1,59 @@
+require 'rubystats/probability_distribution'
+require 'rubystats/normal_distribution'
+# This class provides an object for encapsulating lognormal distributions
+module Rubystats
+  class LognormalDistribution < Rubystats::ProbabilityDistribution
+    include Rubystats::SpecialMath
+
+    # Constructs a lognormal distribution.
+    def initialize(meanlog=0.0, sdlog=1.0)
+      raise "Argument Error: standard deviation for log-normal distribution must be positive." if sdlog < 0.0
+      @meanlog = meanlog.to_f
+      @sdlog = sdlog.to_f      
+      @norm = Rubystats::NormalDistribution.new(@meanlog, @sdlog)
+    end
+
+    # Returns the mean of the distribution
+    def get_mean 
+      return Math.exp(@meanlog + @sdlog**2 / 2.0)
+    end
+
+    # Returns the standard deviation of the distribution
+    def get_standard_deviation
+      return Math.sqrt(get_variance)
+    end
+
+    # Returns the variance of the distribution
+    def get_variance
+      return (Math.exp(@sdlog**2) - 1) * Math.exp(2.0 * @meanlog + @sdlog**2)
+    end
+
+    private
+
+    # Obtain single PDF value
+    # Returns the probability that a stochastic variable x has the value X,
+    # i.e. P(x=X)
+    def get_pdf(x)
+      raise "Argument Error: x must be greater than zero" if x <= 0.0
+      return 1.0/x.to_f * @norm.pdf(Math.log(x.to_f))
+    end
+
+    # Obtain single CDF value
+    # Returns the probability that a stochastic variable x is less than X,
+    # i.e. P(x<X)
+    def get_cdf(x)
+      return 0.5 + 0.5 * Math.erf((Math.log(x.to_f) - @meanlog) /  (NumericalConstants::SQRT2 * @sdlog))
+    end
+
+    # Obtain single inverse CDF value.
+    #	returns the value X for which P(x&lt;X).
+    def get_icdf(p)
+      raise "method 'get_icdf' not implemented for log-normal"
+    end
+
+    # returns single random number from log normal
+    def get_rng
+      return Math.exp(@norm.rng)
+    end
+  end
+end

data/lib/rubystats/modules.rb

@@ -6,6 +6,12 @@ module Rubystats
     end
   end
 
+  module MakeDiscrete
+    def pmf(x)
+      pdf(x)
+    end
+  end  
+  
   module NumericalConstants
     MAX_FLOAT = 3.40282346638528860e292
     EPS = 2.22e-16

data/lib/rubystats/multivariate_normal_distribution.rb

@@ -0,0 +1,73 @@
+require 'rubystats/probability_distribution'
+require 'rubystats/normal_distribution'
+require 'matrix' 
+
+module Rubystats
+  module MultivariateDistribution
+    #override probability_distribution pdf function to work with multivariate input variables
+    def pdf(x)
+      get_pdf(x)
+    end    
+  end
+  class MultivariateNormalDistribution < Rubystats::ProbabilityDistribution
+    include Rubystats::NumericalConstants
+    include Rubystats::MultivariateDistribution
+    
+    def initialize(mu=[0.0,0.0],sigma=[[1.0,0.0],[0.0,1.0]])       
+      raise "dimensions of mu vector and sigma matrix doesn't match" if mu.size != sigma.size
+      sigma.each{|row| raise "row dim of sigma does not match mu vector" if row.size != mu.size }
+      
+      mu_f = mu.collect{|x| x.to_f }
+      sigma_f = sigma.collect{|row| row.collect{|x| x.to_f}}
+      
+      @mu = Vector.elements(mu_f)
+      @sigma = Matrix.rows(sigma_f)      
+      u, d, u_inv = @sigma.eigensystem
+      @sigma_inv = u * (1/d) * u_inv      
+      @a = u * (d)**(0.5)
+      
+      @pdf_factor = 1.0 / Math.sqrt((TWO_PI * @sigma).determinant.to_f)
+      @stdnorm = Rubystats::NormalDistribution.new(0.0,1.0)
+    end
+
+    private
+
+    def get_mean 
+      @mu.to_a
+    end
+
+    def get_variance 
+      raise "variance for multivariate normal distribution not implemented"
+    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) 
+      d = Vector.elements(x) - @mu
+      @pdf_factor * Math.exp(-0.5 * d.inner_product(@sigma_inv*d).to_f)
+    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)
+      raise "cdf for multivariate normal distribution not implemented"
+    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 multivariate normal distribution not implemented"
+    end
+
+    # Private method to obtain single RNG value.
+    def get_rng   
+      z = Vector.elements(@mu.collect{ @stdnorm.rng })
+      (@mu + @a * z).to_a
+    end
+
+  end
+end
+

data/lib/rubystats/normal_distribution.rb

@@ -11,11 +11,11 @@ module Rubystats
     # Constructs a normal distribution (defaults to zero mean and
     # unity variance).
     def initialize(mu=0.0, sigma=1.0)
-      @mean = mu
+      @mean = mu.to_f
       if sigma <= 0.0
         raise "error, invalid sigma #{sigma}, should be > 0"
       end
-      @stdev = sigma
+      @stdev = sigma.to_f
       @variance = sigma**2
       @pdf_denominator = SQRT2PI * Math.sqrt(@variance)
       @cdf_denominator = SQRT2   * Math.sqrt(@variance)