rubystats 0.2.6 → 0.3.0

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)

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.3.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