rubystats 0.2.6 → 0.4.0

data/lib/rubystats/poisson_distribution.rb

@@ -0,0 +1,78 @@
+require 'rubystats/probability_distribution'
+
+module Rubystats
+  class PoissonDistribution < Rubystats::ProbabilityDistribution 
+    include Rubystats::MakeDiscrete
+
+    # Constructs a Poisson distribution
+    def initialize (rate)
+      if rate <= 0.0
+        raise ArgumentError.new("The rate for the Poisson distribution should be greater than zero.")
+      end
+      @rate = rate.to_f
+    end
+
+    #returns the mean
+    def get_mean
+      @rate
+    end
+
+    #returns the variance
+    def get_variance
+      @rate
+    end
+
+    # Private methods below
+
+    private
+
+    # Probability mass function of a Poisson distribution .
+    # k should be an integer
+    # returns the probability that a stochastic variable x has the value k,
+    # i.e. P(x = k)
+    def get_pdf(k)
+      raise ArgumentError.new("Poisson pdf: k needs to be >= 0") if k < 0
+      (@rate**k) * Math.exp(-@rate) / get_factorial(k).to_f
+    end
+
+    # Private shared function for getting cumulant for particular x
+    # param k should be integer-valued
+    # returns the probability that a stochastic variable x is less than _x
+    # i.e P(x < k)
+    def get_cdf(k)
+      raise ArgumentError.new("Poisson pdf: k needs to be >= 0") if k < 0
+      sum = 0.0
+      for i in (0 .. k) 
+        sum = sum + get_pdf(i)
+      end
+      return sum
+    end
+
+    # Inverse of the cumulative Poisson distribution function 
+    def get_icdf(prob)
+      check_range(prob)
+      sum = 0.0
+      k = 0
+      until prob <= sum 
+        sum += get_pdf(k)
+        k += 1
+      end 
+      return k - 1
+    end
+
+    # Private Poisson RNG function
+    # Poisson generator based upon the inversion by sequential search
+    def get_rng
+      x = 0
+      p = Math.exp(-@rate)
+      s = p
+      u = Kernel.rand
+      while u > s
+        x += 1
+        p *= @rate / x.to_f
+        s += p
+      end
+      x
+    end
+  end
+end

data/lib/rubystats/probability_distribution.rb

@@ -122,15 +122,15 @@ module Rubystats
     def check_range(x, lo=0.0, hi=1.0)
       raise ArgumentError.new("x cannot be nil") if x.nil?
       if x < lo or x > hi
-        raise ArgumentError.new("x must be less than lo (#{lo}) and greater than hi (#{hi})") 
+        raise ArgumentError.new("x must be greater than lo (#{lo}) and less than hi (#{hi})") 
       end
     end
 
     def get_factorial(n)
       if n <= 1
         return 1
-      else 
-        return n * get_factorial(n-1)
+      else
+        return n.downto(1).reduce(:*)
       end
     end
 

data/lib/rubystats/student_t_distribution.rb

@@ -0,0 +1,62 @@
+require 'rubystats/probability_distribution'
+require 'rubystats/normal_distribution'
+# This class provides an object for encapsulating student t distributions
+module Rubystats
+  class StudentTDistribution < Rubystats::ProbabilityDistribution
+    include Rubystats::SpecialMath
+
+    # Constructs a student t distribution.
+    def initialize(degree_of_freedom=1.0)
+      raise "Argument Error: degrees of freedom for student t distribution must be greater than zero." if degree_of_freedom <= 0.0
+      @dof = degree_of_freedom.to_f   
+      @pdf_factor = Math.gamma((@dof + 1.0) / 2.0) / ( Math.sqrt(@dof * Math::PI) * Math.gamma(@dof / 2.0))	  
+	  @stdnorm = Rubystats::NormalDistribution.new(0.0,1.0)	  
+    end
+
+    # Returns the mean of the distribution
+    def get_mean
+      (@dof > 1) ? 0.0 : Float::NAN      
+    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
+      (@dof > 2.0) ? (@dof / (@dof - 2)) : Float::NAN      
+    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)      
+      return @pdf_factor * (1.0 + (x**2.0) / @dof)**(-(@dof+1.0)/2.0)
+    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)
+      raise "method 'cdf' not implemented for student t"
+    end
+
+    # Obtain single inverse CDF value.
+    #	returns the value X for which P(x&lt;X).
+    def get_icdf(p)
+      raise "method 'icdf' not implemented for student t"
+    end
+
+    # returns single random number from the student t distribution
+    def get_rng
+	  k = @dof.to_i
+	  samples = []
+	  k.times {|i| samples << @stdnorm.rng }
+	  factor = 1.0 / Math.sqrt(samples.inject(0.0) {|sum,x| sum + x**2} / k)
+      return (factor * @stdnorm.rng)
+    end
+  end
+end

data/lib/rubystats/uniform_distribution.rb

@@ -0,0 +1,70 @@
+require 'rubystats/probability_distribution'
+# This class provides an object for encapsulating uniform distributions
+module Rubystats
+  class UniformDistribution < Rubystats::ProbabilityDistribution
+    include Rubystats::SpecialMath
+
+    # Constructs a uniform distribution (defaults to zero lower and
+    # unity upper bound).
+    def initialize(lower=0.0, upper=1.0)
+      lower,upper = upper,lower if lower > upper
+      @lower = lower.to_f
+      @upper = upper.to_f
+      @pdf_denominator = 1.0 / (@upper - @lower)
+      @use_last = nil
+    end
+
+    # Returns the mean of the distribution
+    def get_mean 
+      return 0.5*(@lower + @upper)
+    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 1.0/12.0 * (@upper-@lower)**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)
+      if x >= @lower && x <= @upper
+        @pdf_denominator
+      else 
+        0.0
+      end	  
+    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)
+      if x >= @lower && x < @upper
+        (x - @lower).fdiv(@upper - @lower)
+      elsif x >= @upper
+        1.0
+      else 
+        0.0
+      end	  
+    end
+
+    # Obtain single inverse CDF value.
+    #	returns the value X for which P(x&lt;X).
+    def get_icdf(p)
+      check_range(p)
+      return @lower + p.to_f * (@upper - @lower)
+    end
+
+    # returns single random number
+    def get_rng
+      return @lower + (@upper - @lower) * Kernel.rand
+    end
+  end
+end

data/lib/rubystats/version.rb

@@ -1,3 +1,3 @@
 module Rubystats
-  VERSION = '0.2.6'
+  VERSION = '0.4.0'
 end

data/lib/rubystats/weibull_distribution.rb

@@ -0,0 +1,56 @@
+require 'rubystats/probability_distribution'
+module Rubystats
+  class WeibullDistribution < Rubystats::ProbabilityDistribution
+    include Rubystats::NumericalConstants
+   
+    def initialize(scale=1.0, shape=1.0) 
+      if scale <= 0.0
+        raise ArgumentError.new("Scale parameter should be greater than zero.")
+      end
+      if shape <= 0.0
+        raise ArgumentError.new("Shape parameter should be greater than zero.")
+      end
+      @scale = scale.to_f 
+      @shape = shape.to_f 
+    end
+
+    private
+
+    def get_mean 
+      @scale * Math.gamma(1.0 + 1.0 / @shape) 
+    end
+
+    def get_variance 
+      @scale**2 * (Math.gamma(1.0 + 2.0 / @shape) - (Math.gamma(1.0 + 1.0 / @shape))**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)
+      (@shape / @scale) * (x / @scale)**(@shape-1.0) * Math.exp(-1.0 * ((x/@scale)**@shape))
+    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)
+      1.0 - Math.exp(-1.0 * ((x.to_f/@scale)**@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)
+      @scale * (-1.0 * Math.log(1.0 - p.to_f))**(1.0 / @shape)
+    end
+
+    # Private method to obtain single RNG value.
+    def get_rng   
+      self.icdf(Kernel.rand)
+    end
+
+  end
+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/rubystats.gemspec

@@ -20,5 +20,11 @@ Gem::Specification.new do |s|
 
   s.add_development_dependency("minitest", ">= 4.2", "< 5.0")
   s.add_development_dependency("hoe", ">= 1.7.0")
+  if RUBY_VERSION >= "3.1"
+    # matrix was removed from default gems in Ruby 3.1, see
+    # https://github.com/ruby/ruby/pull/4530 and https://stdgems.org/
+    s.add_runtime_dependency("matrix")
+  end
+
 end
 

data/test/tc_beta.rb

@@ -96,5 +96,26 @@ class TestBeta < MiniTest::Unit::TestCase
     ucl=bin.icdf(1-alpha)
     return ucl
   end
+  
+  def test_rng_distribution
+    p = 4.0
+    q = 12.0
+    beta = Rubystats::BetaDistribution.new(p,q)
+	
+    total = 10000
+    values = Array.new(total).map{ beta.rng }
+
+    mean = values.inject(0.0) {|sum,v| sum + v} / values.size
+    assert_in_epsilon 0.25, mean.round(2), 0.01	
+  end
 
+  def test_integer_input
+    pi, qi = 2, 4
+    pf, qf = 2.0, 4.0
+    x = 0.25
+    dbetai = Rubystats::BetaDistribution.new(pi,qi).pdf(x)
+    dbetaf = Rubystats::BetaDistribution.new(pf,qf).pdf(x)
+    assert_in_delta dbetai, dbetaf, 0.00000001   
+  end
+  
 end

data/test/tc_binomial.rb

@@ -10,13 +10,27 @@ class TestBinomial < MiniTest::Unit::TestCase
 
     bin = Rubystats::BinomialDistribution.new(t,p)
     cdf = bin.cdf(f)
+    pmf = bin.pmf(f)
     pdf = bin.pdf(f)
     mean = bin.mean
     inv_cdf = bin.icdf(cdf)
 
+    assert_equal pmf, pdf
     assert_in_delta(0.10602553736479, pdf, 0.00000000000001 )
     assert_in_delta(0.87203952137960, cdf, 0.00000000000001)
     assert_equal("5.0",mean.to_s)
     assert_equal(f,inv_cdf)
   end
+  
+  def test_rng
+    t, p = 100, 0.75
+    bin = Rubystats::BinomialDistribution.new(t,p)
+  
+    rngs = []
+    n = 1000
+    n.times { rngs << bin.rng.to_f }
+    avg = rngs.reduce(:+) / rngs.size    
+    
+    assert_in_delta(avg, bin.mean, 0.5)
+  end
 end

data/test/tc_cauchy.rb

@@ -0,0 +1,39 @@
+$:.unshift File.join(File.dirname(__FILE__), "..", "lib")
+require 'minitest/autorun'
+require 'rubystats/cauchy_distribution'
+
+class TestCauchy < MiniTest::Unit::TestCase
+  def test_simple
+    location = 0.0
+    scale = 0.5
+    cd = Rubystats::CauchyDistribution.new(location,scale)
+    assert_in_delta(0.6366198, cd.pdf(0.0), 0.000001)
+    assert_in_delta(0.5, cd.cdf(0.0), 0.00000001)
+    assert_in_delta(3.169765, cd.icdf(0.9502), 0.000001)
+   
+   # make sure the mean of RNG values is close to the expected mean
+    rngs = []
+    n = 10000
+    n.times {|i| rngs << cd.rng }
+    quantile = rngs.sort[(0.75*rngs.size).ceil] 
+    assert_in_delta(quantile, 0.5, 0.1)
+
+    x_vals = [-2.0, -1.0, -0.5, 0.0, 0.5, 1.0, 2.0]
+    
+    x_vals.each do |x|
+      cdf = cd.cdf(x)
+      inv_cdf = cd.icdf(cdf)
+      assert_in_delta(x, inv_cdf, 0.00000001)
+    end
+  end
+  
+  def test_integer_input
+    locationi, scalei = 3, 1
+    locationf, scalef = 3.0, 1.0
+    xi = 4
+    xf = 4.0
+    dcdi = Rubystats::CauchyDistribution.new(locationi,scalei).pdf(xi)
+    dcdf = Rubystats::CauchyDistribution.new(locationf,scalef).pdf(xf)
+    assert_in_delta dcdi, dcdf, 0.00000001   
+  end
+end

data/test/tc_exponential.rb

@@ -57,4 +57,14 @@ class TestExponential < MiniTest::Unit::TestCase
       assert_in_delta(x, inv_cdf, 0.00000001)
     end
   end
+  
+  def test_integer_input
+    lambdai = 2
+    lambdaf = 2.0
+    xi = 3
+    xf = 3.0
+    dexpi = Rubystats::ExponentialDistribution.new(lambdai).pdf(xi)
+    dexpf = Rubystats::ExponentialDistribution.new(lambdaf).pdf(xf)
+    assert_in_delta dexpi, dexpf, 0.00000001   
+  end
 end

data/test/tc_gamma.rb

@@ -0,0 +1,39 @@
+$:.unshift File.join(File.dirname(__FILE__), "..", "lib")
+require 'minitest/autorun'
+require 'rubystats/gamma_distribution'
+
+class TestGamma < MiniTest::Unit::TestCase
+  def test_simple
+    shape = 3.0
+    scale = 2.0
+    gamma = Rubystats::GammaDistribution.new(shape,scale)
+   
+    #check properties
+    assert_in_delta(6.0, gamma.mean, 0.000001)
+    assert_in_delta(12.0, gamma.variance, 0.000001)
+    
+    #check distributions
+    assert_in_delta(0.0, gamma.pdf(0.0), 0.000001)
+    assert_in_delta(0.1353353, gamma.pdf(4.0), 0.000001)
+    assert_in_delta(0.001134998, gamma.pdf(20.0), 0.000001)
+    assert_in_delta(0.5768099, gamma.cdf(6.0), 0.01)
+    assert_in_delta(0.986246, gamma.cdf(16.0), 0.01)
+    
+   # make sure the mean of RNG values is close to the expected mean
+    rngs = []
+    n = 10000
+    n.times {|i| rngs << gamma.rng }
+    quantile = rngs.sort[(0.75*rngs.size).ceil] 
+    assert_in_delta(quantile, 7.84080, 0.2)
+  end
+  
+  def test_integer_input
+    shapei, scalei = 3, 1
+    shapef, scalef = 3.0, 1.0
+    xi = 4
+    xf = 4.0
+    pdfi = Rubystats::GammaDistribution.new(shapei,scalei).pdf(xi)
+    pdff = Rubystats::GammaDistribution.new(shapef,scalef).pdf(xf)
+    assert_in_delta pdfi, pdff, 0.00000001   
+  end
+end

data/test/tc_lnorm.rb

@@ -0,0 +1,45 @@
+$:.unshift File.join(File.dirname(__FILE__), '..', 'lib')
+require 'minitest/autorun'
+require 'rubystats/lognormal_distribution'
+
+class TestLognormal < MiniTest::Unit::TestCase
+  def test_cdf_pdf
+    lnorm = Rubystats::LognormalDistribution.new(2.0,0.2)
+    
+    cdf = lnorm.cdf(8.0)
+    assert_in_epsilon cdf, 0.654392, 0.0001, "cdf"
+  
+    pdf = lnorm.pdf(8.0)
+    assert_in_epsilon pdf, 0.2304252, 0.000001, "pdf"
+  
+  end
+
+  def test_properties
+    lnorm = Rubystats::LognormalDistribution.new(2.0,0.2)
+    assert_in_epsilon lnorm.mean, 7.538325, 0.000001, "mean"
+    assert_in_epsilon lnorm.variance, 2.319127, 0.000001, "variance"
+  end
+  
+  def test_rng
+    lnorm = Rubystats::LognormalDistribution.new(2.0,0.2)
+    
+    total = 100000
+    values = Array.new(total).map{lnorm.rng}
+
+    mean = values.inject(0.0) {|sum, v| sum + v} / values.size
+    
+    assert_in_delta mean, 7.538325, 0.1, "rng mean"
+    assert_equal values.min >= 0.0, true, "rng min value"
+  end
+  
+  def test_integer_input
+    meani, sdi = 2, 1
+    meanf, sdf = 2.0, 1.0
+    xi = 9
+    xf = 9.0
+    dlnormi = Rubystats::LognormalDistribution.new(meani,sdi).pdf(xi)
+    dlnormf = Rubystats::LognormalDistribution.new(meanf,sdf).pdf(xf)
+    assert_in_delta dlnormi, dlnormf, 0.000001   
+  end
+  
+end

data/test/tc_multivariate_normal.rb

@@ -0,0 +1,53 @@
+$:.unshift File.join(File.dirname(__FILE__), "..", "lib")
+require 'minitest/autorun'
+require 'rubystats/multivariate_normal_distribution'
+
+class TestMultivariateNormal < MiniTest::Unit::TestCase
+  def test_simple
+    mu = [1.3,-2.5]
+    sigma = [[1.0,0.3],[0.3,1.0]]    
+    
+    mvnorm = Rubystats::MultivariateNormalDistribution.new(mu,sigma)
+    
+    assert_in_delta(0.0001340771, mvnorm.pdf([1.0,1.0]), 0.000001)
+    assert_in_delta(0.131732, mvnorm.pdf([1.0,-2.0]), 0.000001)
+    
+   
+   # make sure the mean of RNG values is close to the expected mean
+    rngs = []
+    n = 5000
+    n.times {|i| rngs << mvnorm.rng }
+   
+    a,b = rngs.transpose
+   
+    #check means
+    mean_a = a.inject(0.0) {|sum,x| sum + x} / a.size
+    assert_in_delta(1.3, mean_a, 0.1)
+    
+    mean_b = b.inject(0.0) {|sum,x| sum + x} / b.size
+    assert_in_delta(1.3, mean_a, 0.1)
+    
+    #check variances
+    var_a = a.inject(0.0) {|sum,x| sum + (x - mean_a)**2 } / a.size
+    assert_in_delta(1.0, var_a, 0.1)
+    
+    var_b = b.inject(0.0) {|sum,x| sum + (x - mean_b)**2 } / b.size
+    assert_in_delta(1.0, var_b, 0.1)
+    
+    #check correlation
+    covariance = a.zip(b).map{|xa,xb| (xa-mean_a)*(xb-mean_b)}.inject(0.0){|sum,x| sum + x} / a.size
+    correlation = covariance / Math.sqrt(var_a * var_b)
+    assert_in_delta(0.3, correlation, 0.1)    
+    
+  end
+  
+  def test_integer_input
+    mui, sigmai = [1,2], [[1,0.3],[0.3,1]]
+    muf, sigmaf = [1.0,2.0], [[1.0,0.3],[0.3,1.0]]
+    xi = [1,1]
+    xf = [1.0,1.0]
+    dmvnormi = Rubystats::MultivariateNormalDistribution.new(mui,sigmai).pdf(xi)
+    dmvnormf = Rubystats::MultivariateNormalDistribution.new(muf,sigmaf).pdf(xf)
+    assert_in_delta dmvnormi, dmvnormf, 0.00000001   
+  end
+end

data/test/tc_norm.rb

@@ -28,6 +28,16 @@ class TestNormal < MiniTest::Unit::TestCase
 
     three_sigma = two_sigma + histogram[7] + histogram[12]
     assert_in_epsilon 0.997300203937 , three_sigma.to_f / total, 0.005, 'the 3-sigma-environment should contain 99.7%'
-
   end
+  
+  def test_integer_input
+    meani, sdi = 10, 2
+    meanf, sdf = 10.0, 2.0
+    xi = 11
+    xf = 11.0
+    dnormi = Rubystats::NormalDistribution.new(meani,sdi).pdf(xi)
+    dnormf = Rubystats::NormalDistribution.new(meanf,sdf).pdf(xf)
+    assert_in_delta dnormi, dnormf, 0.00000001   
+  end
+  
 end

data/test/tc_poisson.rb

@@ -0,0 +1,35 @@
+$:.unshift File.join(File.dirname(__FILE__), "..", "lib")
+require 'minitest/autorun'
+require 'rubystats/poisson_distribution'
+
+class TestPoisson < MiniTest::Unit::TestCase
+  def test_simple
+    rate = 3.5
+    k = 6
+    
+    pois = Rubystats::PoissonDistribution.new(rate)
+    cdf = pois.cdf(k)
+    pmf = pois.pmf(k)
+    pdf = pois.pdf(k)
+    mean = pois.mean
+    inv_cdf = pois.icdf(cdf)
+
+    assert_equal pmf, pdf
+    assert_in_delta(0.0770984, pdf, 0.0000001 )
+    assert_in_delta(0.9347119, cdf, 0.0000001)
+    assert_equal(k,inv_cdf)
+    assert_equal(3.5,mean)
+  end
+  
+  def test_rng
+    rate = 3.5
+    pois = Rubystats::PoissonDistribution.new(rate)
+  
+    rngs = []
+    n = 1000
+    n.times { rngs << pois.rng.to_f }
+    avg = rngs.reduce(:+) / rngs.size    
+    
+    assert_in_delta(avg, pois.mean, 0.5)
+  end
+end