Add more discrete distributions (#25)

* distributions: discrete: Negative binomial.

Add negative binomial distribution and unit tests.

* distribution: discrete: Geometric distribution.

This change adds the geometric distribution to the list of discrete
functions.

* distribution: discrete: Bernoulli distribution.

* distribution: discrete: LogSeries distribution.

* gem: Bump to version 2.0.5.

* distribution: beta: Add uncovered case where alpha + beta == 0.

lib/statistics/distribution/bernoulli.rb

@@ -0,0 +1,35 @@
+module Statistics
+ module Distribution
+ class Bernoulli
+ def self.density_function(n, p)
+ return if n != 0 && n != 1 # The support of the distribution is n = {0, 1}.
+
+ case n
+ when 0 then 1.0 - p
+ when 1 then p
+ end
+ end
+
+ def self.cumulative_function(n, p)
+ return if n != 0 && n != 1 # The support of the distribution is n = {0, 1}.
+
+ case n
+ when 0 then 1.0 - p
+ when 1 then 1.0
+ end
+ end
+
+ def self.variance(p)
+ p * (1.0 - p)
+ end
+
+ def self.skewness(p)
+ (1.0 - 2.0*p).to_f / Math.sqrt(p * (1.0 - p))
+ end
+
+ def self.kurtosis(p)
+ (6.0 * (p ** 2) - (6 * p) + 1) / (p * (1.0 - p))
+ end
+ end
+ end
+end

lib/statistics/distribution/geometric.rb

@@ -0,0 +1,76 @@
+module Statistics
+ module Distribution
+ class Geometric
+ attr_accessor :probability_of_success, :always_success_allowed
+
+ def initialize(p, always_success: false)
+ self.probability_of_success = p.to_f
+ self.always_success_allowed = always_success
+ end
+
+ def density_function(k)
+ k = k.to_i
+
+ if always_success_allowed
+ return if k < 0
+
+ ((1.0 - probability_of_success) ** k) * probability_of_success
+ else
+ return if k <= 0
+
+ ((1.0 - probability_of_success) ** (k - 1.0)) * probability_of_success
+ end
+ end
+
+ def cumulative_function(k)
+ k = k.to_i
+
+ if always_success_allowed
+ return if k < 0
+
+ 1.0 - ((1.0 - probability_of_success) ** (k + 1.0))
+ else
+ return if k <= 0
+
+ 1.0 - ((1.0 - probability_of_success) ** k)
+ end
+ end
+
+ def mean
+ if always_success_allowed
+ (1.0 - probability_of_success) / probability_of_success
+ else
+ 1.0 / probability_of_success
+ end
+ end
+
+ def median
+ if always_success_allowed
+ (-1.0 / Math.log2(1.0 - probability_of_success)).ceil - 1.0
+ else
+ (-1.0 / Math.log2(1.0 - probability_of_success)).ceil
+ end
+ end
+
+ def mode
+ if always_success_allowed
+ 0.0
+ else
+ 1.0
+ end
+ end
+
+ def variance
+ (1.0 - probability_of_success) / (probability_of_success ** 2)
+ end
+
+ def skewness
+ (2.0 - probability_of_success) / Math.sqrt(1.0 - probability_of_success)
+ end
+
+ def kurtosis
+ 6.0 + ((probability_of_success ** 2) / (1.0 - probability_of_success))
+ end
+ end
+ end
+end

lib/statistics/distribution/logseries.rb

@@ -0,0 +1,51 @@
+module Statistics
+ module Distribution
+ class LogSeries
+ def self.density_function(k, p)
+ return if k <= 0
+ k = k.to_i
+
+ left = (-1.0 / Math.log(1.0 - p))
+ right = (p ** k).to_f
+
+ left * right / k
+ end
+
+ def self.cumulative_function(k, p)
+ return if k <= 0
+
+ # Sadly, the incomplete beta function is converging
+ # too fast to zero and breaking the calculation on logs.
+ # So, we default to the basic definition of the CDF which is
+ # the integral (-Inf, K) of the PDF, with P(X <= x) which can
+ # be solved as a summation of all PDFs from 1 to K. Note that the summation approach
+ # only applies to discrete distributions.
+ #
+ # right = Math.incomplete_beta_function(p, (k + 1).floor, 0) / Math.log(1.0 - p)
+ # 1.0 + right
+
+ result = 0.0
+ 1.upto(k) do |number|
+ result += self.density_function(number, p)
+ end
+
+ result
+ end
+
+ def self.mode
+ 1.0
+ end
+
+ def self.mean(p)
+ (-1.0 / Math.log(1.0 - p)) * (p / (1.0 - p))
+ end
+
+ def self.variance(p)
+ up = p + Math.log(1.0 - p)
+ down = ((1.0 - p) ** 2) * (Math.log(1.0 - p) ** 2)
+
+ (-1.0 * p) * (up / down.to_f)
+ end
+ end
+ end
+end

lib/statistics/distribution/negative_binomial.rb

@@ -0,0 +1,51 @@
+module Statistics
+ module Distribution
+ class NegativeBinomial
+ attr_accessor :number_of_failures, :probability_per_trial
+
+ def initialize(r, p)
+ self.number_of_failures = r.to_i
+ self.probability_per_trial = p
+ end
+
+ def probability_mass_function(k)
+ return if number_of_failures < 0 || k < 0 || k > number_of_failures
+
+ left = Math.combination(k + number_of_failures - 1, k)
+ right = ((1 - probability_per_trial) ** number_of_failures) * (probability_per_trial ** k)
+
+ left * right
+ end
+
+ def cumulative_function(k)
+ return if k < 0 || k > number_of_failures
+ k = k.to_i
+
+ 1.0 - Math.incomplete_beta_function(probability_per_trial, k + 1, number_of_failures)
+ end
+
+ def mean
+ (probability_per_trial * number_of_failures)/(1 - probability_per_trial).to_f
+ end
+
+ def variance
+ (probability_per_trial * number_of_failures)/((1 - probability_per_trial) ** 2).to_f
+ end
+
+ def skewness
+ (1 + probability_per_trial).to_f / Math.sqrt(probability_per_trial * number_of_failures)
+ end
+
+ def mode
+ if number_of_failures > 1
+ up = probability_per_trial * (number_of_failures - 1)
+ down = (1 - probability_per_trial).to_f
+
+ (up/down).floor
+ elsif number_of_failures <= 1
+ 0.0
+ end
+ end
+ end
+ end
+end

lib/statistics/version.rb

@@ -1,3 +1,3 @@
 module Statistics
- VERSION = "2.0.4"
+ VERSION = "2.0.5"
 end

spec/statistics/distribution/bernoulli_spec.rb

@@ -0,0 +1,62 @@
+require 'spec_helper'
+
+describe Statistics::Distribution::Bernoulli do
+ describe '.density_function' do
+ it 'is not defined when the outcome is different from zero or one' do
+ expect(described_class.density_function(rand(2..10), rand)).to be_nil
+ expect(described_class.density_function(rand(-5..-1), rand)).to be_nil
+ end
+
+ it 'returns the expected value when the outcome is zero' do
+ p = rand
+ expect(described_class.density_function(0, p)).to eq (1.0 - p)
+ end
+
+ it 'returns the expected value when the outcome is one' do
+ p = rand
+ expect(described_class.density_function(1, p)).to eq p
+ end
+ end
+
+ describe '.cumulative_function' do
+ it 'is not defined when the outcome is different from zero or one' do
+ expect(described_class.cumulative_function(rand(2..10), rand)).to be_nil
+ expect(described_class.density_function(rand(-5..-1), rand)).to be_nil
+ end
+
+ it 'returns the expected value when the outcome is zero' do
+ p = rand
+ expect(described_class.cumulative_function(0, p)).to eq (1.0 - p)
+ end
+
+ it 'returns the expected value when the outcome is one' do
+ expect(described_class.cumulative_function(1, rand)).to eq 1.0
+ end
+ end
+
+ describe '.variance' do
+ it 'returns the expected value for the bernoulli distribution' do
+ p = rand
+
+ expect(described_class.variance(p)).to eq p * (1.0 - p)
+ end
+ end
+
+ describe '.skewness' do
+ it 'returns the expected value for the bernoulli distribution' do
+ p = rand
+ expected_value = (1.0 - 2.0*p).to_f / Math.sqrt(p * (1.0 - p))
+
+ expect(described_class.skewness(p)).to eq expected_value
+ end
+ end
+
+ describe '.kurtosis' do
+ it 'returns the expected value for the bernoulli distribution' do
+ p = rand
+ expected_value = (6.0 * (p ** 2) - (6 * p) + 1) / (p * (1.0 - p))
+
+ expect(described_class.kurtosis(p)).to eq expected_value
+ end
+ end
+end

spec/statistics/distribution/beta_spec.rb

@@ -62,11 +62,21 @@
  expect(described_class.new(alpha, beta).mean).to be_nil
  end
 
+ it 'returns nil if the sum of alpha and beta is zero' do
+ alpha = -1
+ beta = 1
+
+ expect(described_class.new(alpha, beta).mean).to be_nil
+ end
+
  it 'calculates the expected mean for the beta distribution' do
  alpha = rand(-5..5)
  beta = rand(-5..5)
 
- alpha = 1 if alpha + beta == 0 # To avoid NaN results.
+ if alpha + beta == 0 # To avoid NaN results.
+ alpha = 1
+ beta = 1
+ end
 
  expect(described_class.new(alpha, beta).mean).to eq alpha.to_f/(alpha.to_f + beta.to_f)
  end