distribution 0.7.3 → 0.8.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
-SHA1:
-  metadata.gz: 4904710a92ef44ae987119ac6c214ea860735cd9
-  data.tar.gz: 8a6381d47062634afade73cafbcd093603db985b
+SHA256:
+  metadata.gz: b3c0292d160b0f59129c73e352855422d7f1d35cbc8eac916419a7146c5ee4eb
+  data.tar.gz: 63f7693122a361948ad79f60e26d5ab060fe69982477cf96e0eb7815dcf29d29
 SHA512:
-  metadata.gz: 9142471e941e7a2a44ecc727c698fc18bf46da46964e0f49ea2e80ebd829284a1b53284ceaed4135d7ac9ade786e04a4bc155d9e3bb104151925f1d88b6ec9f8
-  data.tar.gz: 2f019d5d7388e7af9c0d7d4e93f02eacdd06ac302bc5d7f72172e8fa6df00fc5c23fbe99a035f87989ad2cb692da523eaa1127338e3f673da84b3e006a0a69b3
+  metadata.gz: aa9d6ccb96e181214325ad90a1bba142bb46b2b23c2826c314ece10e55de139e613999a63e0477ea9ba595158a4544fa9758ff6f0ea4eff04ac2c2a568502e67
+  data.tar.gz: 5730f217be13735748570c0b45d56c3a04dc6f0dffeee39b97addb64e4eadd6a03d3d731f25a99903a9624a999be58308116b494e46342ef0ecd9b36293a4f1a

data/.travis.yml

@@ -1,11 +1,8 @@
 language: ruby
 rvm:
-  - 1.9.3
-  - 2.0
-  - 2.1
-  - 2.2
-#  - jruby-19mode # JRuby in 1.9 mode -> Problems with bigint
-#  - rbx-19mode
+  - 2.5
+  - 2.6
+  - 2.7
 
 script:
   bundle exec rake
@@ -13,3 +10,4 @@ script:
 before_install:
   - sudo apt-get update -qq
   - sudo apt-get install -y libgsl0-dev
+  - gem update && gem install bundler

data/.yardopts

@@ -0,0 +1,5 @@
+--title "Distribution"
+--markup markdown
+lib/**/*.rb
+README.md History.txt
+

data/History.txt

@@ -1,3 +1,6 @@
+=== 0.7.4 / 2018-04-11
+  * Removed reference to deprecated Fixnum class.
+
 === 0.7.3 / 2015-05-28
   * Fixed F::Ruby_.p_value.
 

data/README.md

@@ -3,76 +3,99 @@
 [![Build Status](https://travis-ci.org/SciRuby/distribution.svg?branch=master)](https://travis-ci.org/SciRuby/distribution)
 [![Code Climate](https://codeclimate.com/github/SciRuby/distribution/badges/gpa.svg)](https://codeclimate.com/github/SciRuby/distribution)
 
+Distribution is a gem with several probabilistic distributions. Pure Ruby is used by default, C (GSL) or Java extensions are used if available. Some facts:
+
+- Very fast ruby 1.9.3+ implementation, with improved method to calculate factorials and other common functions.
+- All methods tested on several ranges. See `spec/`.
+- Code for normal, Student's t and chi square is lifted from the [statistics2 gem](https://rubygems.org/gems/statistics2). Originally at [this site](http://blade.nagaokaut.ac.jp/~sinara/ruby/math/statistics2).
+- The code for some functions and RNGs was lifted from Julia's [Rmath-julia](https://github.com/JuliaLang/Rmath-julia), a patched version of R's standalone math library.
+
+The following table lists the available distributions and the methods available for each one. If a field is marked with an *x*, that distribution doesn't have that method implemented.
+
+| Distribution     | PDF | CDF | Quantile | RNG | Mean | Mode | Variance | Skewness | Kurtosis | Entropy |
+| :--------------- | :-: | :-: | :------: | :-: | :--: | :--: | :------: | :------: | :------: | :-----: |
+| Uniform          |     |     |          |     | x    | x    | x        | x        | x        | x       |
+| Normal           |     |     |          |     | x    | x    | x        | x        | x        | x       |
+| Lognormal        |     |     | x        | x   | x    | x    | x        | x        | x        | x       |
+| Bivariate Normal |     |     | x        | x   | x    | x    | x        | x        | x        | x       |
+| Exponential      |     |     |          |     | x    | x    | x        | x        | x        | x       |
+| Logistic         |     |     |          |     | x    | x    | x        | x        | x        | x       |
+| Student's T      |     |     |          | x   | x    | x    | x        | x        | x        | x       |
+| Chi Square       |     |     |          |     | x    | x    | x        | x        | x        | x       |
+| Fisher-Snedecor  |     |     |          | x   | x    | x    | x        | x        | x        | x       |
+| Beta             |     |     |          | x   | x    | x    | x        | x        | x        | x       |
+| Gamma            |     |     | x        | x   | x    | x    | x        | x        | x        | x       |
+| Weibull          |     |     |          | x   | x    | x    | x        | x        | x        | x       |
+| Binomial         |     |     |          | x   | x    | x    | x        | x        | x        | x       |
+| Poisson          |     |     |          |     | x    | x    | x        | x        | x        | x       |
+| Hypergeometric   |     |     |          | x   | x    | x    | x        | x        | x        | x       |
+
 ## Installation
 
 ```
 $ gem install distribution
 ```
 
-If you have GSL installed and want to speed things up, install `rb-gsl`:
+You can install GSL for better performance:
+
+* For Mac OS X: `brew install gsl`
+* For Ubuntu / Debian: `sudo apt-get install libgsl0-dev`
+
+After successfully installing the library:
 
 ```bash
 $ gem install rb-gsl
 ```
 
-## Description
-
-Statistical Distributions library. Includes Normal univariate and bivariate, T, F, Chi Square, Binomial, Hypergeometric, Exponential, Poisson, Beta, LogNormal and Gamma.
-
-Uses Ruby by default and C (statistics2/GSL) or Java extensions where available.
-
-Includes code from statistics2 on Normal, T, F and Chi Square ruby code [http://blade.nagaokaut.ac.jp/~sinara/ruby/math/statistics2]
-
-## Synopsis
-
-* Returns Gaussian PDF for x
-
-```
-pdf=Distribution::Normal.pdf(x)
-```
+## Examples
 
-* Returns Gaussian CDF for x
+You can find automatically generated documentation on [RubyDoc](http://www.rubydoc.info/github/sciruby/distribution/master).
 
 ```
-cdf=Distribution::Normal.cdf(x)
-```
+# Returns Gaussian PDF for x.
+pdf = Distribution::Normal.pdf(x)
 
-* Returns inverse CDF (or p-value) for x
+# Returns Gaussian CDF for x.
+cdf = Distribution::Normal.cdf(x)
 
-```
-pv=Distribution::Normal.p_value(x)
-```
+# Returns inverse CDF (or p-value) for x.
+pv = Distribution::Normal.p_value(x)
 
-## Developers
+# API.
 
-```
-$ git clone https://github.com/SciRuby/distribution.git
-```
+# You would normally use the following
+p = Distribution::T.cdf(x)
 
-If you want to provide a new distribution, run `lib/distribution`:
+# to get the cumulative probability of `x`. However, you can also:
 
-```
-$ distribution --new your_distribution
+include Distribution::Shorthand
+tdist_cdf(x)
 ```
 
-This should create the main distribution file, the directory with Ruby and GSL engines and specs on the spec/ directory.
-
 ## API Structure
 
-  Distribution::<name>.(cdf|pdf|p_value|rng)
+```ruby
+Distribution::<name>.(cdf|pdf|p_value|rng)
+```
 
 On discrete distributions, exact Ruby implementations of pdf, cdf and p_value could be provided, using
+
 ```
   Distribution::<name>.exact_(cdf|pdf|p_value)
 ```
+
 module Distribution::Shorthand provides (you guess?) shortands method to call all methods
+
 ```
   <Distribution shortname>_(cdf|pdf|p|r)
 ```
+
 On discrete distributions, exact cdf, pdf and p_value are
+
 ```
   <Distribution shortname>_(ecdf|epdf|ep)
 ```
+
 Shortnames for distributions:
 
   * Normal: norm
@@ -87,26 +110,46 @@ Shortnames for distributions:
   * Beta: beta
   * Gamma: gamma
   * LogNormal: lognormal
+  * Uniform: unif
 
-### API Structure Example
+## Roadmap
 
-```
-  Distribution::T.cdf
-```
+This gem wasn't updated for a long time before I started working on it, so there are a lot of work to do. The first priority is cleaning the interface and removing cruft whenever possible. After that, I want to implement more distributions and make sure that each one has a RNG.
 
-could be called after including Distribution::Shorthand
+### Short-term
 
-```
-  tdist_cdf
-```
+- Define a minimal interface for continuous and discrete distributions (e.g. mean, variance, mode, skewness, kurtosis, pdf, cdf, quantile, cquantile).
+- Implement `Distribution::Uniform` with the default Ruby `Random`.
+- Clean up the implementation of normal distribution. Implement the necessary functions.
+- The same for Student's t, chi square, Fisher-Snedecor, beta, gamma, lognormal, logistic.
+- The same for discrete distributions: binomial, hypergeometric, bernoulli (still missing), etc.
+
+### Medium-term
 
-## Features
+- Implement [DSFMT](http://www.math.sci.hiroshima-u.ac.jp/~m-mat/MT/SFMT/) for the uniform random generator.
+- Cauchy distribution.
 
-* Very fast ruby 1.8.7/1.9.+ implementation, with improved method to calculate factorials and others common functions
-* All methods tested on several ranges. See spec/
+### Long-term
+
+- Implementing everything in the distributions x functions table above.
 
 ## Issues
 
 * On JRuby and Rubinius, BivariateNormal returns incorrect pdf
 
 For current issues see the [issue tracker pages](https://github.com/sciruby/distribution/issues).
+
+## OMG! I want to help!
+
+Everyone is welcome to help! Please, test these distributions with your own use
+cases and give a shout on the issue tracker if you find a problem or something
+is strange or hard to use. Documentation pull requests are totally welcome.
+More generally, any ideas or suggestions are welcome -- even by private e-mail.
+
+If you want to provide a new distribution, run `lib/distribution`:
+
+```
+$ distribution --new your_distribution
+```
+
+This should create the main distribution file, the directory with Ruby and GSL engines and specs on the spec/ directory.

data/benchmark/binomial_coefficient.rb

@@ -1,56 +1,52 @@
-$:.unshift(File.expand_path(File.dirname(__FILE__)+"/../lib"))
+$LOAD_PATH.unshift(File.expand_path(File.dirname(__FILE__) + '/../lib'))
 require 'distribution'
 require 'bench_press'
 
 extend BenchPress
 
-
-
-samples=10.times.map {|i| 2**(i+1)}
+samples = 10.times.map { |i| 2**(i + 1) }
 
 name 'binomial coefficient: multiplicative, factorial and optimized factorial methods'
 author 'Claudio Bustos'
 date '2011-01-27'
-summary "Exact calculation of Binomial Coefficient could be obtained using multiplicative, pure factorial or optimized factorial algorithm (failing + factorial). 
+summary "Exact calculation of Binomial Coefficient could be obtained using multiplicative, pure factorial or optimized factorial algorithm (failing + factorial).
 Which one is faster?
 
-Lower k is the best for all 
+Lower k is the best for all
 k=n/2 is the worst case.
 
 The factorial method uses the fastest Swing Prime Algorithm."
 
-reps 10 #number of repetitions
-
-x=100
-
-n=100
-k=50
+reps 10 # number of repetitions
 
+x = 100
 
+n = 100
+k = 50
 
-measure "Multiplicative" do
+measure 'Multiplicative' do
   samples.each do |n|
-    [5,n/2].each do |k|
-      k=[k,n-k].min
-      (1..k).inject(1) {|ac, i| (ac*(n-k+i).quo(i))}
+    [5, n / 2].each do |k|
+      k = [k, n - k].min
+      (1..k).inject(1) { |ac, i| (ac * (n - k + i).quo(i)) }
     end
   end
 end
 
-measure "Pure Factorial" do
+measure 'Pure Factorial' do
   samples.each do |n|
-    [5,n/2].each do |k|
-      k=[k,n-k].min
+    [5, n / 2].each do |k|
+      k = [k, n - k].min
       Math.factorial(n).quo(Math.factorial(k) * Math.factorial(n - k))
     end
   end
 end
 
-measure "Failing factorial + factorial" do
+measure 'Failing factorial + factorial' do
   samples.each do |n|
-    [5,n/2].each do |k|
-      k=[k,n-k].min
-      (((n-k+1)..n).inject(1) {|ac,v| ac * v}).quo(Math.factorial(k))
+    [5, n / 2].each do |k|
+      k = [k, n - k].min
+      (((n - k + 1)..n).inject(1) { |ac, v| ac * v }).quo(Math.factorial(k))
     end
   end
 end

data/benchmark/binomial_coefficient/experiment.rb

@@ -1,54 +1,51 @@
 # This test create a database to adjust the best algorithm
 # to use on correlation matrix
-$:.unshift(File.expand_path(File.dirname(__FILE__)+"/../../lib"))
+$LOAD_PATH.unshift(File.expand_path(File.dirname(__FILE__) + '/../../lib'))
 require 'distribution'
 require 'statsample'
 require 'benchmark'
 
-if !File.exists?("binomial_coefficient.ds") or File.mtime(__FILE__) > File.mtime("binomial_coefficient.ds")
-reps=100 #number of repetitions
-ns={
-  5=>    [1,3],
-  10=>   [1,3,5],
-  50=>   [1,3,5,10,25],
-  100=>  [1,3,5,10,25,50],
-  500=>  [1,3,5,10,25,50,100,250],
-  1000=> [1,3,5,10,25,50,100,250,500],
-  5000=> [1,3,5,10,25,50,100,250,500,1000,2500],
-  10000=>[1,3,5,10,25,50,100,250,500,1000,2500,5000]
-}
-
-rs=Statsample::Dataset.new(%w{n k mixed_factorial multiplicative})
-
-ns.each do |n,ks|
-  ks.each do |k|
-      
-      time_factorial= Benchmark.realtime do
-        reps.times { 
-           (((n-k+1)..n).inject(1) {|ac,v| ac * v}).quo(Math.factorial(k))
+if !File.exist?('binomial_coefficient.ds') or File.mtime(__FILE__) > File.mtime('binomial_coefficient.ds')
+  reps = 100 # number of repetitions
+  ns = {
+    5 => [1, 3],
+    10 => [1, 3, 5],
+    50 => [1, 3, 5, 10, 25],
+    100 => [1, 3, 5, 10, 25, 50],
+    500 => [1, 3, 5, 10, 25, 50, 100, 250],
+    1000 => [1, 3, 5, 10, 25, 50, 100, 250, 500],
+    5000 => [1, 3, 5, 10, 25, 50, 100, 250, 500, 1000, 2500],
+    10_000 => [1, 3, 5, 10, 25, 50, 100, 250, 500, 1000, 2500, 5000]
+  }
+
+  rs = Statsample::Dataset.new(%w(n k mixed_factorial multiplicative))
+
+  ns.each do |n, ks|
+    ks.each do |k|
+      time_factorial = Benchmark.realtime do
+        reps.times {
+          (((n - k + 1)..n).inject(1) { |ac, v| ac * v }).quo(Math.factorial(k))
         }
       end
-      
-      time_multiplicative= Benchmark.realtime do
-        reps.times { 
-          (1..k).inject(1) {|ac, i| (ac*(n-k+i).quo(i))}
+
+      time_multiplicative = Benchmark.realtime do
+        reps.times {
+          (1..k).inject(1) { |ac, i| (ac * (n - k + i).quo(i)) }
         }
       end
-      
+
       puts "n:#{n}, k:#{k} -> factorial:%0.3f | multiplicative: %0.3f " % [time_factorial, time_multiplicative]
-      
-      rs.add_case({'n'=>n,'k'=>k,'mixed_factorial'=>time_factorial, 'multiplicative'=>time_multiplicative})
+
+      rs.add_case('n' => n, 'k' => k, 'mixed_factorial' => time_factorial, 'multiplicative' => time_multiplicative)
     end
   end
-  
+
 else
-  rs=Statsample.load("binomial_coefficient.ds")
+  rs = Statsample.load('binomial_coefficient.ds')
 end
 
-
-rs.fields.each {|f| rs[f].type=:scale}
-
+rs.fields.each { |f| rs[f].type = :scale }
 
 rs.update_valid_data
-rs.save("binomial_coefficient.ds")
-Statsample::Excel.write(rs,"binomial_coefficient.xls")
+rs.save('binomial_coefficient.ds')
+Statsample::Excel.write(rs, 'binomial_coefficient.xls')

data/benchmark/factorial_hash.rb

@@ -1,4 +1,4 @@
-$:.unshift(File.expand_path(File.dirname(__FILE__)+"/../lib"))
+$LOAD_PATH.unshift(File.expand_path(File.dirname(__FILE__) + '/../lib'))
 require 'bench_press'
 require 'distribution'
 extend BenchPress
@@ -8,17 +8,16 @@ author 'Claudio Bustos'
 date '2011-01-31'
 summary "
 Is better create a lookup table for factorial or just calculate it?
-Distribution::MathExtension::SwingFactorial has a lookup table 
+Distribution::MathExtension::SwingFactorial has a lookup table
 for factorials n<20
 "
 
-reps 1000 #number of repetitions
+reps 1000 # number of repetitions
 
-measure "Lookup" do
-	Math.factorial(19)
+measure 'Lookup' do
+  Math.factorial(19)
 end
 
-measure "calculate" do
-	Distribution::MathExtension::SwingFactorial.naive_factorial(19)
+measure 'calculate' do
+  Distribution::MathExtension::SwingFactorial.naive_factorial(19)
 end
-

data/benchmark/factorial_method.rb

@@ -1,4 +1,4 @@
-$:.unshift(File.dirname(__FILE__)+"/../lib")
+$LOAD_PATH.unshift(File.dirname(__FILE__) + '/../lib')
 require 'distribution'
 require 'bench_press'
 
@@ -10,19 +10,17 @@ date '2011-01-27'
 summary "
 Factorization requires a lot of processing, so approximation method could be  required. But for greats value, bigdecimal are required and things start to get harder.
 * Approximation (fast_factorial): Luschny f.3
-* Exact (factorial): Luschny Swing Prime 
+* Exact (factorial): Luschny Swing Prime
 "
 
-reps 10 #number of repetitions
+reps 10 # number of repetitions
 
-x=200
+x = 200
 
 measure "Math.factorial(#{x})" do
   Math.factorial(x)
 end
 
 measure "Math.fast_factorial(#{x})" do
-  
   Math.fast_factorial(x)
 end
-