bernoulli 0.3.1 → 0.4

data/Gemfile

@@ -1,4 +1,2 @@
 source :rubygems
-
 gemspec
-

data/LICENSE.md

@@ -0,0 +1,22 @@
+Copyright (c) 2012 Mikael Konutgan
+
+MIT License
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.md

@@ -1,8 +1,11 @@
-# Bernoulli : A Ruby library for the binomial distribution
+# Bernoulli: Discrete probability distribution library for Ruby
 
-In probability theory and statistics, the **binomial distribution** is the discrete probability distribution of the number of successes in a sequence of *n* independent yes/no experiments, each of which yields success with probability *p*.
+**Bernoulli** implements the four most common discrete probability distributions in an object oriented manner and in pure Ruby.
 
-You can read more about **Bernoulli trials** and the **binomial distribution** [on Wikipedia](http://en.wikipedia.org/wiki/Binomial_distribution).
+- The binomial distribution
+- The geometric distribution
+- The hypergeometric distribution
+- The Poisson distribution
 
 ## Installation
 
@@ -12,76 +15,66 @@ Use RubyGems to install `bernoulli`
 
 ## Tutorial
 
-Using `bernoulli`, one can calculate the probabilities of bernoulli experiments.
+The classes in `bernoulli` reprsent random variables:
 
-Let's start by looking at an example.
+    Bernoulli::Distribution::<DistributionName>
+    
+If, for example you wanted to have a geometrically distributed random variable with parameter 0.43, you would do:
 
-**Question:** What is the chance of getting between 25 and 36 sixes when one rolls a die 180 times? What is the expected value and variance of this trial?
+    y = Bernoulli::Distribution::Geometric.new(0.43)
+    
+Also if you `require 'bernoulli/shorthand'` too, you will get top level shortcut functions to create new instances of all distributions:
 
-Let's use `bernoulli` to solve this:
+- `binomdist`
+- `geomdist`
+- `hgeomdist`
+- `poissondist`
 
-First we load up `irb` from the terminal including `bernoulli` as a library.
+So `y = geomdist(0.43)` would be equivalent to the code shown above.
+    
+After this you call methods on `y`. The methods avalible to all distributions are:
 
-	$ irb -r bernoulli
-	
-Or we could just `require 'bernoulli'` in any Ruby script.
+- `probability`
+- `probability_range`
+- `expected_value`
+- `variance`
+- `standard_deviation`
+- `skewness`
+- `excess`
 
-Then we create a new instance of class Bernoulli and calculate our desired probability and properties like so
+Again, shortcuts include (but this time included automatically):
 
-	x = Bernoulli::Distribution.new(180, 1.0/6)
-	# => #<Bernoulli::Distribution @n=180, @p=0.16666666666666666>
-	
-	# The probability of getting between 25 and 36 sixes is
-	x[25..36] # => 0.7665588897840108
-	
-	x.expected_value # => 30.0
-	x.variance # => 25.0
-	
-We could also calculate the standard deviation, excess or skewness:
-	
-	x.standard_deviation # => 5.0
-	x.excess # => 0.006666666666666665
-	x.skewness # => 0.13333333333333336
-	
-`bernoulli` can also do empirical tests. Let's look at a smaller example We can simulate the tossing of 4 fair coins
+- `ev` for `expected_value`
+- `v` for `variance`
+- `sd` for `standard_deviation`
+- `[]`, which takes a number or a range and then executes `probability` or `probability_range`
 
-	y = Bernoulli::Distribution.new(4, 0.5)
-	# => #<Bernoulli::Distribution @n=4, @p=0.5>
+### Example
 
-The method `sample` gives as a random array of length `n`, where each entry is `1` with a probability of `p`. The methods `sample_value` gives us the number of wins in a random expriment, we could than compare it to `expected_value`.
+    require 'bernoulli'
+    require 'bernoulli/shorthand'
+    
+    x = binomdist(180, 1.0/6)
+    # => #<Distribution::Binomial @n=180, @p=0.16666666666666666>
+    
+    x.ev # => 30.0
+    x.v # => 25.0
+    x[25..36] # => 0.7665588897840108
+    
+Last, but not least, there are two methods exclusive to the binomial distribution:
 
-	y.sample # => [1, 0, 1, 0]
-	y.sample # => [0, 0, 1, 0]
-	y.sample # => [1, 1, 1, 1]
+The method `sample` returns a random array of length `n`, where each entry is 1 with a probability of `p`. This is esentially modelling a binomial experiment.
 
-	y.sample_value # => 2
-	y.sample_value # => 1
-	y.sample_value # => 0
-	y.sample_value # => 2
-	
-	y.expected_value # => 2.0
-
-Last, but not least, we can create a full table of all possible values and their probabilitys like so
-
-	puts y.table
-	
-will produce
-
-	0,0.0625
-	1,0.25
-	2,0.375
-	3,0.25
-	4,0.0625
+The method `sample_value` returns the number of successes in a random binomial expriment that was executed using `sample`. `sv` is a shortcut for `sample_value`.
 
 ## Contributing
 
-`bernoulli` is a really small project. After writing the same code for some project and then losing it two or three times I decided to do it one time and well, so I can just call in the code from here next time.
+`bernoulli` is a small project. After writing the same code for some project and then losing it two or three times I decided to do it one time and well, so I can just call in the code from here next time.
 
-Feel free to cantact me about anything I could/should add  or to contribute in any way to this simple library.
+Feel free to cantact me about anything I could/should add or to contribute in any way to this simple library.
 
 1. Fork it
 2. Create your feature branch (`git checkout -b my-new-feature`)
 3. Commit your changes (`git commit -am 'added some feature'`)
 4. Push to the branch (`git push origin my-new-feature`)
 5. Create new Pull Request
-

data/Rakefile

@@ -1,14 +1,23 @@
-require 'rake/testtask'
 require 'bundler/gem_tasks'
+require 'rake/testtask'
+require 'yard'
 
 task :default => :test
 
-Rake::TestTask.new do |test|
+Rake::TestTask.new do |t|
+  t.libs << 'test'
+  t.pattern = 'test/**/test*.rb'
 end
 
-desc 'Remove pkg directory'
+YARD::Rake::YardocTask.new do |t|
+  t.files = ['lib/**/*.rb']
+  t.options = ['--markup=markdown']
+end
+
+desc 'Remove pkg and doc directories'
 task :clean do
   rm_rf 'pkg/'
+  rm_rf 'doc/'
 end
 
 spec = eval File.read('bernoulli.gemspec')
@@ -17,4 +26,3 @@ desc "Remove and uninstall #{spec.name}-#{spec.version}.gem from system gems"
 task :uninstall => :clean do
   sh 'gem uninstall bernoulli'
 end
-

data/bernoulli.gemspec

@@ -4,22 +4,21 @@ Gem::Specification.new do |spec|
   
   spec.name = 'bernoulli'
   spec.version = Bernoulli::VERSION
-  spec.summary = 'Binomial experiments library'
-  spec.description = 'A library that allows calculation of probibilities and properties of binomial experiments like coin tossing'
+  spec.summary = 'Discrete probability distribution library for Ruby'
+  spec.description = 'Bernoulli implements standard methods used for statistcal calculations with discrete probability distributions in an object oriented manner and in pure Ruby'
   spec.homepage = 'http://mkonutgan.github.com/bernoulli'
   
   spec.author = 'Mikael Konutgan'
-  spec.email = 'mkonutgan@shortmail.com'
+  spec.email = 'mkonutgan@gmail.com'
   
   spec.required_ruby_version = '>= 1.8.7'
   spec.required_rubygems_version = '>= 1.3.6'
   
-  spec.files = `git ls-files`.split($\)
-  spec.test_files = spec.files.grep(/test/)
+  spec.files = `git ls-files`.split
+  spec.test_files = spec.files.grep(/test_/)
   
-  spec.add_development_dependency 'minitest', '~> 3.0.1'
-  spec.add_development_dependency 'rake', '~> 0.9.2.2'
-  spec.add_development_dependency 'bundler', '~> 1.1.4'
+  spec.add_development_dependency 'minitest', '>= 2.5'
+  spec.add_development_dependency 'rake', '>= 0.9'
+  spec.add_development_dependency 'bundler', '>= 1.1'
       
 end
-

data/lib/bernoulli.rb

@@ -1,85 +1,2 @@
-require 'bernoulli/math'
 require 'bernoulli/version'
-
-module Bernoulli
-  class Distribution
-  
-    def initialize(n, p)
-      if n < 0 or p > 1.0 or p < 0.0 or not n.is_a? Integer
-        raise 'Could not initialize Bernoulli experiment'
-      end
-      @n = n
-      @p = p
-    end
-    
-    def to_s
-      "#<Bernoulli::Distribution @n=#@n, @p=#@p>"
-    end
-    
-    def probability(k)
-      Math.binomial(@n, k) * @p**k * (1 - @p)**(@n - k)
-    end
-    
-    def [](k)
-      if k.is_a? Integer
-        raise Math::DomainError if not (k <= @n and k >= 0)
-        probability(k).to_f
-      elsif k.is_a? Range
-        raise Math::DomainError if not (k.begin >= 0 and k.end <= @n)
-        sum = 0
-        k.each do |i|
-          sum += probability(i)
-        end
-        sum.to_f
-      else
-        raise TypeError
-      end
-    end
-    
-    def sample
-      s = []
-      @n.times do
-        s << (rand < @p ? 1 : 0)
-      end
-      s
-    end
-    
-    def sample_value
-      sample.count(1)
-    end
-    alias :sv :sample_value
-    
-    def expected_value
-      @n * @p
-    end
-    alias :ev :expected_value
-    
-    def variance
-      @n * @p * (1 - @p)
-    end
-    alias :v :variance
-    
-    def standard_deviation
-      Math.sqrt(variance)
-    end
-    alias :sd :standard_deviation
-    
-    def skewness
-      (1 - 2 * @p) / (Math.sqrt(@n * @p * (1 - @p)))
-    end
-    
-    def excess
-      (1 - 6 * @p * (1 - @p)) / (@n * @p * (1 - @p))
-    end
-    
-    def table
-      csv = ""
-      (0..@n).each do |n|
-        csv << n.to_s << "," << probability(n).to_s << "\n"
-      end
-      csv
-    end
-  
-  end
-end
-
+require 'bernoulli/distribution'

data/lib/bernoulli/distribution.rb

@@ -0,0 +1,40 @@
+require 'bernoulli/distribution/binomial'
+require 'bernoulli/distribution/hypergeometric'
+require 'bernoulli/distribution/geometric'
+require 'bernoulli/distribution/poisson'
+
+module Bernoulli
+  
+  # Top level Module for all the probability distributions
+  # Also provides convinience methods and `#standard_deviation`, which
+  # is calculated the same way independent of the distribution
+  module Distribution
+    
+    # Calculate the sum of the probabilities across a range
+    # @param r [Range]
+    def probability_range(r)
+      r.inject(0) { |s, k| s + probability(k) }
+    end
+    
+    # A shortcut to the `#probability` and `#probability_range`
+    # methods
+    # @param k [Integer, Range]
+    def [](k)
+      if k.is_a? Integer
+        probability(k).to_f
+      elsif k.is_a? Range
+        probability_range(k).to_f
+      else
+        raise TypeError, 'Expecting Integer or Range - "[]"'
+      end
+    end
+    
+    # The standard deviation of a random variable
+    # is the square root of its variance.
+    def standard_deviation
+      Math.sqrt(variance)
+    end
+    alias :sd :standard_deviation
+    
+  end
+end

data/lib/bernoulli/distribution/binomial.rb

@@ -0,0 +1,71 @@
+require 'bernoulli/math'
+
+module Bernoulli
+  
+  module Distribution
+    
+    # Implements binomially distributed random variable
+    # See http://en.wikipedia.org/wiki/Binomial_distribution
+    # for more information
+    class Binomial
+      
+      include Distribution
+      
+      # @param n [Integer] the number of trials (>= 0)
+      # @param p [Float] success probability in each trial
+      def initialize(n, p)
+        if n < 0 or p > 1.0 or p < 0.0
+          raise 'Expecting n >= 0 and 0.0 <= p <= 1.0'
+        end
+        @n = n.to_i
+        @p = p.to_f
+      end
+      
+      def to_s
+        "#<Distribution::Binomial @n=#@n, @p=#@p>"
+      end
+      
+      # @param k [Integer] the number of successes (>= 0)
+      # @return [Float] the probability of `k` successes
+      def probability(k)
+        Math.binomial(@n, k) * @p**k * (1 - @p)**(@n - k)
+      end
+      
+      # Preform a binomial experiment of length `@n` and probability `@p`
+      # @return [Array<0, 1>] the resulting random array
+      def sample
+        s = []
+        @n.times do
+          s << (rand < @p ? 1 : 0)
+        end
+        s
+      end
+      
+      # @return [Integer] number of 1's in a run of `#sample`
+      def sample_value
+        sample.count(1)
+      end
+      alias :sv :sample_value
+      
+      def expected_value
+        @n * @p
+      end
+      alias :ev :expected_value
+      
+      def variance
+        @n * @p * (1 - @p)
+      end
+      alias :v :variance
+      
+      def skewness
+        (1 - 2 * @p) / (Math.sqrt(@n * @p * (1 - @p)))
+      end
+      
+      def excess
+        (1 - 6 * @p * (1 - @p)) / (@n * @p * (1 - @p))
+      end
+      
+    end
+    
+  end
+end

data/lib/bernoulli/distribution/geometric.rb

@@ -0,0 +1,56 @@
+module Bernoulli
+
+  module Distribution
+    
+    # Implements geometrically distributed random variable
+    # See http://en.wikipedia.org/wiki/Geometric_distribution
+    # for more information
+    class Geometric
+
+      include Distribution
+      
+      # @param p [Float] the success probability (>= 0, <= 1)
+      def initialize(p)
+        if p > 1.0 or p < 0.0
+          raise 'Expecting 0.0 <= p <= 1.0'
+        end
+        @p = p.to_f
+      end
+
+      def to_s
+        "#<Distribution::Geometric @p=#@p>"
+      end
+      
+      # @param k [Integer] number of independent trials (> 0)
+      # @return [Float] the probability that the first occurrence
+      #   of success require `k` independent trials
+      def probability(k)
+        if k == 0
+          0
+        else
+          (1 - @p)**(k - 1) * @p
+        end
+      end
+
+      def expected_value
+        1 / @p
+      end
+      alias :ev :expected_value
+
+      def variance
+        (1 - @p) / @p**2
+      end
+      alias :v :variance
+
+      def skewness
+        (2 - @p) / Math.sqrt(1 - @p)
+      end
+
+      def excess
+        6 + @p**2 / (1 - @p)
+      end
+
+    end
+
+  end
+end

data/lib/bernoulli/distribution/hypergeometric.rb

@@ -0,0 +1,55 @@
+require 'bernoulli/math'
+
+module Bernoulli
+
+  module Distribution
+    
+    # Implements hypergeometrically distributed random variable
+    # See http://en.wikipedia.org/wiki/Hypergeometric_distribution
+    # for more information
+    class Hypergeometric
+
+      include Distribution
+      
+      # @param bn [Integer] the size of the population (big n) (> 0)
+      # @param m [Integer] the number of successes (>= 0, <= bn)
+      # @param n [Integer] the number of draws (>= 1, <= bn)
+      def initialize(bn, m, n)
+        if bn < 1 or m < 0 or m > bn or n < 1 or n > bn
+          raise 'Expecting bn > 1, 0 < m < bn, 0 < n < bn'
+        end
+        @bn, @m, @n = bn.to_i, m.to_i, n.to_i
+      end
+
+      def to_s
+        "#<Distribution::Hypergeometric @bn=#@bn, @m=#@m, @n=#@n>"
+      end
+      
+      # @param k [Integer] number of successes (>= 0)
+      # @return [Float] the probability of `k` successes
+      def probability(k)
+        (Math.binomial(@m, k) * Math.binomial(@bn - @m, @n - k)).to_f / Math.binomial(@bn, @n)
+      end
+
+      def expected_value
+        @n * (@m.to_f / @bn)
+      end
+      alias :ev :expected_value
+
+      def variance
+        (@n * @m * (@bn - @m) *(@bn - @n)).to_f / (@bn * @bn * (@bn - 1))
+      end
+      alias :v :variance
+
+      def skewness
+        ((@bn - 2 * @m) * Math.sqrt(@bn - 1) * (@bn - 2 * @n)) / (Math.sqrt(@n * @m * (@bn - @m) * (@bn - @n)) * (@bn - 2))
+      end
+  
+      def excess
+        ((@bn - 1) * @bn * @bn * (@bn * (@bn + 1) - 6 * @m * (@bn - @m) - 6 * @n * (@bn - @n)) + 6 * @n * @m * (@bn - @m) * (@bn - @n) * (5 * @bn - 6)).to_f / (@n * @m * (@bn - @m) * (@bn - @n) * (@bn - 2) * (@bn - 3))
+      end
+
+    end
+
+  end
+end

data/lib/bernoulli/distribution/poisson.rb

@@ -0,0 +1,58 @@
+require 'bernoulli/math'
+
+module Bernoulli
+  
+  module Distribution
+    
+    # Implements Poisson distributed random variable
+    # See http://en.wikipedia.org/wiki/Poisson_distribution
+    # for more information
+    class Poisson
+      
+      include Distribution
+      
+      # @param l [Float] the avarage rate of success in a time period
+      def initialize(l)
+        if l <= 0.0
+          raise 'Expecting l > 0.0'
+        end
+        @l = l.to_f
+      end
+      
+      def to_s
+        "#<Distribution::Poisson @l=#@l>"
+      end
+      
+      # @param k [Integer] number of successes (>= 0)
+      # @return [Float] the probability of `k` successes
+      # in the time period
+      def probability(k)
+        (@l**k / Math.factorial(k)) * Math.exp(-@l)
+      end
+      
+      def probability_range(r)
+        Math.exp(-@l) * r.inject(0) { |s, k| s + (@l**k / Math.factorial(k)) }
+      end
+      
+      def expected_value
+        @l
+      end
+      alias :ev :expected_value
+      
+      def variance
+        @l
+      end
+      alias :v :variance
+      
+      def skewness
+        1 / Math.sqrt(@l)
+      end
+      
+      def excess
+        1 / @l
+      end
+      
+    end
+    
+  end
+end

data/lib/bernoulli/math.rb

@@ -1,8 +1,9 @@
+# Extend the Ruby Math module with common functions used in
+# statstical distributions
 module Math
-
+  
   def self.factorial(n)
-    
-    if n < 0 or not n.is_a? Integer
+    if n < 0
       raise Math::DomainError, 'Numerical argument is out of domain - "factorial"'
     end
     if n == 0
@@ -13,11 +14,11 @@ module Math
   end
   
   def self.binomial(n, k)
-    if n < 0 or n < k or not (n.is_a? Integer and k.is_a? Integer)
-      raise Math::DomainError, 'Numerical argument is out of domain - "binomial"'
+    if n < 0 or k < 0 or n < k
+      0
+    else
+      factorial(n)/(factorial(k) * factorial(n - k))
     end
-    factorial(n)/(factorial(k) * factorial(n - k))
   end
 
 end
-

data/lib/bernoulli/shorthand.rb

@@ -0,0 +1,19 @@
+# shorthand that returns new instance of `Distribution::Binomial`
+def binomdist(n, p)
+  Bernoulli::Distribution::Binomial.new(n, p)
+end
+
+# shorthand that returns new instance of `Distribution::Geometric`
+def geomdist(p)
+  Bernoulli::Distribution::Geometric.new(p)
+end
+
+# shorthand that returns new instance of `Distribution::Hypergeometric`
+def hgeomdist(bn, m, n)
+  Bernoulli::Distribution::Hypergeometric.new(bn, m, n)
+end
+
+# shorthand that returns new instance of `Distribution::Poisson`
+def poissondist(l)
+  Bernoulli::Distribution::Poisson.new(l)
+end

data/lib/bernoulli/version.rb

@@ -1,4 +1,3 @@
 module Bernoulli
-  VERSION = "0.3.1"
+  VERSION = '0.4'
 end
-

data/test/distribution/test_binomial.rb

@@ -0,0 +1,52 @@
+require File.expand_path('../../helper', __FILE__)
+
+class BinomialTest < MiniTest::Unit::TestCase
+
+  def test_new_experiment
+    assert_raises RuntimeError do
+      Bernoulli::Distribution::Binomial.new(10, 1.1)
+    end
+    assert_raises RuntimeError do
+      Bernoulli::Distribution::Binomial.new(-10, 0.7)
+    end
+  end
+
+  def setup
+    @x = Bernoulli::Distribution::Binomial.new(180, 1.0/6)
+    @y = Bernoulli::Distribution::Binomial.new(2, 0.5)
+  end
+
+  def test_to_s
+    assert_equal "#<Distribution::Binomial @n=2, @p=0.5>", @y.to_s
+  end
+
+  def test_coin_toss
+    assert_equal 0.25, @y[0]
+    assert_equal 0.5, @y[1]
+    assert_equal 0.25, @y[2]
+    assert_equal 0.75, @y[0..1]
+    assert_equal 0.75, @y[1..2]
+    assert_equal 1.0, @y[0..2]
+  end
+
+  def test_expected_value
+    assert_equal 30, @x.expected_value
+  end
+
+  def test_variance
+    assert_equal 25, @x.variance
+  end
+
+  def test_standard_deviation
+    assert_equal 5, @x.standard_deviation
+  end
+
+  def test_skewness
+    assert_in_eps 0.1333333333333333, @x.skewness
+  end
+
+  def test_excess
+    assert_in_eps 0.0066666666666667, @x.excess
+  end
+
+end

data/test/distribution/test_geometric.rb

@@ -0,0 +1,43 @@
+require File.expand_path('../../helper', __FILE__)
+
+class GeometricTest < MiniTest::Unit::TestCase
+
+  def setup
+    @x = Bernoulli::Distribution::Geometric.new(0.5)
+    @y = Bernoulli::Distribution::Geometric.new(0.87)
+  end
+
+  def test_to_s
+    assert_equal "#<Distribution::Geometric @p=0.5>", @x.to_s
+  end
+
+  def test_probabilities
+    assert_in_eps 1.0, @x[1..100]
+    assert_in_eps 0.5, @x[1]
+    assert_in_eps 0.25, @x[2]
+  end
+
+  def test_expected_value
+    assert_in_eps 2, @x.expected_value
+    assert_in_eps 1.149425287, @y.expected_value
+  end
+
+  def test_variance
+    assert_in_eps 2, @x.variance
+    assert_in_eps 0.171753204, @y.variance
+  end
+
+  def test_standard_deviation
+    assert_in_eps 1.4142135623730951, @x.standard_deviation
+    assert_in_eps 0.414431181, @y.standard_deviation
+  end
+  
+  def test_skewness
+    assert_in_eps 3.134056109, @y.skewness
+  end
+  
+  def test_excess
+    assert_in_eps 11.822307692, @y.excess
+  end
+
+end

data/test/distribution/test_hypergeometric.rb

@@ -0,0 +1,52 @@
+require File.expand_path('../../helper', __FILE__)
+
+class HypergeometricTest < MiniTest::Unit::TestCase
+
+  def setup
+    @x = Bernoulli::Distribution::Hypergeometric.new(5, 3, 2)
+    @y = Bernoulli::Distribution::Hypergeometric.new(50, 17, 9)
+  end
+
+  def test_to_s
+    assert_equal "#<Distribution::Hypergeometric @bn=5, @m=3, @n=2>", @x.to_s
+  end
+
+  def test_probabilities
+    assert_in_eps 0.1, @x[0]
+    assert_in_eps 0.6, @x[1]
+    assert_in_eps 0.3, @x[2]
+    assert_in_eps 1.0, @x[0..2]
+    assert_in_eps 0.9, @x[1..2]
+    assert_in_eps 0.0, @x[3]
+    assert_in_eps 0.0, @x[4]
+    
+    assert_in_eps 1.0, @y[0..9]
+    assert_in_eps 0.0, @y[10]
+  end
+
+  def test_expected_value
+    assert_in_eps 1.2, @x.expected_value
+    assert_in_eps 3.06, @y.expected_value
+  end
+
+  def test_variance
+    assert_in_eps 0.36, @x.variance
+    assert_in_eps 1.689869388, @y.variance
+  end
+
+  def test_standard_deviation
+    assert_in_eps 0.6, @x.standard_deviation
+    assert_in_eps 1.299949764, @y.standard_deviation
+  end
+  
+  def test_skewness
+    assert_in_eps -0.111111111, @x.skewness
+    assert_in_eps 0.164108906, @y.skewness
+  end
+  
+  def test_excess
+    assert_in_eps -0.444444444, @x.excess
+    assert_in_eps -0.14585017, @y.excess
+  end
+
+end

data/test/distribution/test_poisson.rb

@@ -0,0 +1,64 @@
+require File.expand_path('../../helper', __FILE__)
+
+class PoissonTest < MiniTest::Unit::TestCase
+
+  def setup
+    @x = Bernoulli::Distribution::Poisson.new(1)
+    @y = Bernoulli::Distribution::Poisson.new(112)
+    @z = Bernoulli::Distribution::Poisson.new(54)
+  end
+
+  def test_to_s
+    assert_equal "#<Distribution::Poisson @l=1.0>", @x.to_s
+  end
+  
+  def test_probabilities_1
+    p = [
+      0.36787944117144233,
+      0.36787944117144233,
+      0.18393972058572117,
+      0.061313240195240384,
+      0.015328310048810096,
+      0.0030656620097620196,
+      0.0005109436682936699
+    ]
+    (0..6).each { |v| assert_in_eps p[v], @x[v] }
+    assert_in_eps 1, @x[0..10]
+    assert_in_eps 0.9810118431238463, @x[0..3]
+  end
+  
+  def test_probabilities_2
+    assert_in_eps 0.003324518575716, @y[89]
+    assert_in_eps 0.0143492278868432, @y[0..89]
+  end
+  
+  def test_probabilities_3
+    assert_in_eps 0.0483850390510616, @z[50]
+    assert_in_eps 0.32326350500948, @z[0..50]
+    assert_in_eps 1.0, @z[0..100]
+  end
+
+  def test_expected_value
+    assert_equal 1, @x.expected_value
+    assert_equal 112, @y.expected_value
+  end
+
+  def test_variance
+    assert_equal 1, @x.variance
+    assert_equal 112, @y.variance
+  end
+
+  def test_standard_deviation
+    assert_in_eps 1, @x.standard_deviation
+    assert_in_eps Math.sqrt(112), @y.standard_deviation
+  end
+  
+  def test_skewness
+    assert_in_eps 0.094491118, @y.skewness
+  end
+  
+  def test_excess
+    assert_in_eps 0.008928571, @y.excess
+  end
+
+end

data/test/helper.rb

@@ -0,0 +1,12 @@
+require 'minitest/unit'
+require 'minitest/pride'
+
+require 'bernoulli/distribution'
+
+class MiniTest::Unit::TestCase
+
+  def assert_in_eps exp, act
+    assert_in_delta exp, act, 1.0e-7
+  end
+  
+end

data/test/test_math.rb

@@ -1,24 +1,22 @@
 require 'minitest/autorun'
 require 'minitest/pride'
-require 'bernoulli'
+require 'bernoulli/math'
 
 class MathTest < MiniTest::Unit::TestCase
   
   def test_factorial
     assert_raises(Math::DomainError) { Math.factorial(-1) }
-    assert_raises(Math::DomainError) { Math.factorial(2.4) }
     assert_equal 1, Math.factorial(0)
     assert_equal 1, Math.factorial(1)
+    assert_equal 2, Math.factorial(2)
     assert_equal 120, Math.factorial(5)
     assert_equal 263130836933693530167218012160000000, Math.factorial(32)
   end
   
   def test_binomial
-    pairs = [[-1, 0], [2, 4], [-2, -1], [1.2, 3.4], [12, 50]]
+    pairs = [[-1, 0], [2, 4], [-2, -1], [6, -3], [12, 50]]
     pairs.each do |pair|
-      assert_raises Math::DomainError do
-        Math.binomial *pair
-      end
+      assert_equal 0, Math.binomial(*pair)
     end
     assert_equal 1, Math.binomial(0, 0)
     (1..20).each do |k|
@@ -36,4 +34,3 @@ class MathTest < MiniTest::Unit::TestCase
   end
   
 end
-

data/test/test_shorthand.rb

@@ -0,0 +1,26 @@
+require 'bernoulli/distribution'
+require 'bernoulli/shorthand'
+
+class ShorthandTest < MiniTest::Unit::TestCase
+
+  def test_binomdist
+    x = Bernoulli::Distribution::Binomial.new(10, 0.71)
+    assert_equal x.to_s, binomdist(10, 0.71).to_s
+  end
+  
+  def test_geomdist
+    x = Bernoulli::Distribution::Geometric.new(0.53)
+    assert_equal x.to_s, geomdist(0.53).to_s
+  end
+  
+  def test_hgeomdist
+    x = Bernoulli::Distribution::Hypergeometric.new(20, 14, 5)
+    assert_equal x.to_s, hgeomdist(20, 14, 5).to_s
+  end
+  
+  def test_poissondist
+    x = Bernoulli::Distribution::Poisson.new(13.3)
+    assert_equal x.to_s, poissondist(13.3).to_s
+  end
+  
+end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: bernoulli
 version: !ruby/object:Gem::Version
-  version: 0.3.1
+  version: '0.4'
   prerelease: 
 platform: ruby
 authors:
@@ -9,72 +9,85 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2012-06-09 00:00:00.000000000 Z
+date: 2012-07-04 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: minitest
   requirement: !ruby/object:Gem::Requirement
     none: false
     requirements:
-    - - ~>
+    - - ! '>='
       - !ruby/object:Gem::Version
-        version: 3.0.1
+        version: '2.5'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     none: false
     requirements:
-    - - ~>
+    - - ! '>='
       - !ruby/object:Gem::Version
-        version: 3.0.1
+        version: '2.5'
 - !ruby/object:Gem::Dependency
   name: rake
   requirement: !ruby/object:Gem::Requirement
     none: false
     requirements:
-    - - ~>
+    - - ! '>='
       - !ruby/object:Gem::Version
-        version: 0.9.2.2
+        version: '0.9'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     none: false
     requirements:
-    - - ~>
+    - - ! '>='
       - !ruby/object:Gem::Version
-        version: 0.9.2.2
+        version: '0.9'
 - !ruby/object:Gem::Dependency
   name: bundler
   requirement: !ruby/object:Gem::Requirement
     none: false
     requirements:
-    - - ~>
+    - - ! '>='
       - !ruby/object:Gem::Version
-        version: 1.1.4
+        version: '1.1'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     none: false
     requirements:
-    - - ~>
+    - - ! '>='
       - !ruby/object:Gem::Version
-        version: 1.1.4
-description: A library that allows calculation of probibilities and properties of
-  binomial experiments like coin tossing
-email: mkonutgan@shortmail.com
+        version: '1.1'
+description: Bernoulli implements standard methods used for statistcal calculations
+  with discrete probability distributions in an object oriented manner and in pure
+  Ruby
+email: mkonutgan@gmail.com
 executables: []
 extensions: []
 extra_rdoc_files: []
 files:
 - Gemfile
+- LICENSE.md
 - README.md
 - Rakefile
 - bernoulli.gemspec
 - lib/bernoulli.rb
+- lib/bernoulli/distribution.rb
+- lib/bernoulli/distribution/binomial.rb
+- lib/bernoulli/distribution/geometric.rb
+- lib/bernoulli/distribution/hypergeometric.rb
+- lib/bernoulli/distribution/poisson.rb
 - lib/bernoulli/math.rb
+- lib/bernoulli/shorthand.rb
 - lib/bernoulli/version.rb
-- test/test_bernoulli.rb
+- test/distribution/test_binomial.rb
+- test/distribution/test_geometric.rb
+- test/distribution/test_hypergeometric.rb
+- test/distribution/test_poisson.rb
+- test/helper.rb
 - test/test_math.rb
+- test/test_shorthand.rb
 homepage: http://mkonutgan.github.com/bernoulli
 licenses: []
 post_install_message: 
@@ -98,7 +111,12 @@ rubyforge_project:
 rubygems_version: 1.8.24
 signing_key: 
 specification_version: 3
-summary: Binomial experiments library
+summary: Discrete probability distribution library for Ruby
 test_files:
-- test/test_bernoulli.rb
+- test/distribution/test_binomial.rb
+- test/distribution/test_geometric.rb
+- test/distribution/test_hypergeometric.rb
+- test/distribution/test_poisson.rb
 - test/test_math.rb
+- test/test_shorthand.rb
+has_rdoc: 

data/test/test_bernoulli.rb

@@ -1,61 +0,0 @@
-require 'minitest/autorun'
-require 'minitest/pride'
-require 'bernoulli'
-
-class DistributionTest < MiniTest::Unit::TestCase
-  
-  def test_new_experiment
-    assert_raises RuntimeError do
-      Bernoulli::Distribution.new(10, 1.1)
-    end
-    assert_raises RuntimeError do
-      Bernoulli::Distribution.new(-10, 0.7)
-    end
-    assert_raises RuntimeError do
-      Bernoulli::Distribution.new(4.5, 0.2)
-    end
-  end
-  
-  def setup
-    @x = Bernoulli::Distribution.new(180, 1.0/6)
-    @y = Bernoulli::Distribution.new(2, 0.5)
-    @z = Bernoulli::Distribution.new(4, 0.5)
-  end
-  
-  def test_to_s
-    assert_equal "#<Bernoulli::Distribution @n=2, @p=0.5>", @y.to_s
-  end
-  
-  def test_coin_toss
-    assert_equal 0.5, @y[1]
-    assert_equal 0.25, @y[2]
-    assert_equal 1.0, @y[0..2]
-  end
-  
-  def test_expected_value
-    assert_equal 30, @x.expected_value
-  end
-  
-  def test_variance
-    assert_equal 25, @x.variance
-  end
-  
-  def test_standard_deviation
-    assert_equal 5, @x.standard_deviation
-  end
-  
-  def test_skewness
-    assert_in_delta 0.1333333333333333, @x.skewness, 1.0e-7
-  end
-  
-  def test_excess
-    assert_in_delta 0.0066666666666667, @x.excess, 1.0e-7
-  end
-  
-  def test_table
-    str = "0,0.0625\n1,0.25\n2,0.375\n3,0.25\n4,0.0625\n"
-    assert_equal str, @z.table
-  end
-  
-end
-