distribution 0.6.0 → 0.8.0

data/spec/gamma_spec.rb

@@ -1,85 +1,82 @@
-require File.expand_path(File.dirname(__FILE__)+"/spec_helper.rb")
+require File.expand_path(File.dirname(__FILE__) + '/spec_helper.rb')
 include ExampleWithGSL
 describe Distribution::Gamma do
-
-  
-shared_examples_for "Gamma engine" do
-  it_only_with_gsl "should return correct pdf" do
+  shared_examples_for 'Gamma engine' do
+    it_only_with_gsl 'should return correct pdf' do
       if @engine.respond_to? :pdf
         1.upto(101) do |x|
-          a=rand * x
-          b=1 + rand * 5
-          g=GSL::Ran.gamma_pdf(x,a,b)
-          @engine.pdf(x,a,b).should be_within(1e-10).of(g)
+          a = rand * x
+          b = 1 + rand * 5
+          g = GSL::Ran.gamma_pdf(x, a, b)
+          expect(@engine.pdf(x, a, b)).to be_within(1e-10).of(g)
         end
       else
         pending("No #{@engine}.pdf")
       end
     end
-  it_only_with_gsl "should return correct cdf" do
-    if @engine.respond_to? :cdf
-      # From GSL-1.9.
-      TOL = 1048576.0*Float::EPSILON
-      @engine.cdf(0.0, 1.0, 1.0).should eq(0.0)
-      @engine.cdf(1e-100, 1.0, 1.0).should be_within(TOL).of(1e-100)
-      @engine.cdf(0.001, 1.0, 1.0).should be_within(TOL).of(9.99500166625008332e-4)
-      @engine.cdf(0.01, 1.0, 1.0).should be_within(TOL).of(9.95016625083194643e-3)
-      @engine.cdf(0.1, 1.0, 1.0).should be_within(TOL).of(9.51625819640404268e-2)
-      @engine.cdf(0.325, 1.0, 1.0).should be_within(TOL).of(2.77472646357927811e-1)
-      @engine.cdf(1.0, 1.0, 1.0).should be_within(TOL).of(6.32120558828557678e-1)
-      @engine.cdf(1.5, 1.0, 1.0).should be_within(TOL).of(7.76869839851570171e-1)
-      @engine.cdf(2.0, 1.0, 1.0).should be_within(TOL).of(8.64664716763387308e-1)
-      @engine.cdf(10.0, 1.0, 1.0).should be_within(TOL).of(9.99954600070237515e-1)
-      @engine.cdf(20.0, 1.0, 1.0).should be_within(TOL).of(9.99999997938846378e-1)
-      @engine.cdf(100.0, 1.0, 1.0).should be_within(TOL).of(1e0)
-      @engine.cdf(1000.0, 1.0, 1.0).should be_within(TOL).of(1e0)
-      @engine.cdf(10000.0, 1.0, 1.0).should be_within(TOL).of(1e0)
-    else
-      pending("No #{@engine}.cdf")
+    it_only_with_gsl 'should return correct cdf' do
+      if @engine.respond_to? :cdf
+        # From GSL-1.9.
+        tol = 1_048_576.0 * Float::EPSILON
+        expect(@engine.cdf(0.0, 1.0, 1.0)).to eq(0.0)
+        expect(@engine.cdf(1e-100, 1.0, 1.0)).to be_within(tol).of(1e-100)
+        expect(@engine.cdf(0.001, 1.0, 1.0)).to be_within(tol).of(9.99500166625008332e-4)
+        expect(@engine.cdf(0.01, 1.0, 1.0)).to be_within(tol).of(9.95016625083194643e-3)
+        expect(@engine.cdf(0.1, 1.0, 1.0)).to be_within(tol).of(9.51625819640404268e-2)
+        expect(@engine.cdf(0.325, 1.0, 1.0)).to be_within(tol).of(2.77472646357927811e-1)
+        expect(@engine.cdf(1.0, 1.0, 1.0)).to be_within(tol).of(6.32120558828557678e-1)
+        expect(@engine.cdf(1.5, 1.0, 1.0)).to be_within(tol).of(7.76869839851570171e-1)
+        expect(@engine.cdf(2.0, 1.0, 1.0)).to be_within(tol).of(8.64664716763387308e-1)
+        expect(@engine.cdf(10.0, 1.0, 1.0)).to be_within(tol).of(9.99954600070237515e-1)
+        expect(@engine.cdf(20.0, 1.0, 1.0)).to be_within(tol).of(9.99999997938846378e-1)
+        expect(@engine.cdf(100.0, 1.0, 1.0)).to be_within(tol).of(1e0)
+        expect(@engine.cdf(1000.0, 1.0, 1.0)).to be_within(tol).of(1e0)
+        expect(@engine.cdf(10_000.0, 1.0, 1.0)).to be_within(tol).of(1e0)
+      else
+        pending("No #{@engine}.cdf")
+      end
     end
-  end
-  it "should return correct p_value" do
-    if @engine.respond_to? :p_value
-      1.upto(20) do |x|
-        a=rand()*0.5
-        b=1 + rand() * 5
-        pr=@engine.cdf(x,a,b)
-        @engine.p_value(pr,a,b).should be_within(1e-3).of(x)
-       end
-    else
-      pending("No #{@engine}.p_value")
+    it 'should return correct p_value' do
+      if @engine.respond_to? :p_value
+        1.upto(20) do |x|
+          a = rand * 0.5
+          b = 1 + rand * 5
+          pr = @engine.cdf(x, a, b)
+          expect(@engine.p_value(pr, a, b)).to be_within(1e-3).of(x)
+        end
+      else
+        skip("No #{@engine}.p_value")
+      end
     end
   end
-end
 
-  describe "singleton" do
+  describe 'singleton' do
     before do
-      @engine=Distribution::Gamma
+      @engine = Distribution::Gamma
     end
-    it_should_behave_like "Gamma engine"
+    it_should_behave_like 'Gamma engine'
   end
-  
+
   describe Distribution::Gamma::Ruby_ do
     before do
-      @engine=Distribution::Gamma::Ruby_
+      @engine = Distribution::Gamma::Ruby_
     end
-    it_should_behave_like "Gamma engine"
+    it_should_behave_like 'Gamma engine'
   end
   if Distribution.has_gsl?
     describe Distribution::Gamma::GSL_ do
       before do
-        @engine=Distribution::Gamma::GSL_
+        @engine = Distribution::Gamma::GSL_
       end
-    it_should_behave_like "Gamma engine"
+      it_should_behave_like 'Gamma engine'
     end
   end
   if Distribution.has_java?
     describe Distribution::Gamma::Java_ do
       before do
-        @engine=Distribution::Gamma::Java_
+        @engine = Distribution::Gamma::Java_
       end
-    it_should_behave_like "Gamma engine"
-    end  
+      it_should_behave_like 'Gamma engine'
+    end
   end
-  
 end

data/spec/hypergeometric_spec.rb

@@ -1,6 +1,6 @@
-require File.expand_path(File.dirname(__FILE__)+"/spec_helper.rb")
+require File.expand_path(File.dirname(__FILE__) + '/spec_helper.rb')
 include ExampleWithGSL
-#require 'ruby-prof'
+# require 'ruby-prof'
 
 # Need to test:
 # * that Fixnum fast_choose returns same as choose
@@ -9,105 +9,99 @@ include ExampleWithGSL
 
 describe Distribution::Hypergeometric do
   describe Distribution::Hypergeometric::GSL_ do
-     before do
-      @ruby=Distribution::Hypergeometric::Ruby_
-      @engine=Distribution::Hypergeometric::GSL_
+    before do
+      @ruby = Distribution::Hypergeometric::Ruby_
+      @engine = Distribution::Hypergeometric::GSL_
     end
-    it_only_with_gsl "cdf should return values near to exact Ruby calculations" do
-     #RubyProf.start
-      
+    it_only_with_gsl 'cdf should return values near to exact Ruby calculations' do
+      # RubyProf.start
+
       if @engine.respond_to? :cdf
-        #[2].each do |k|
-         [0,1,2,4,8,16].each do |k|
-          @engine.cdf(k, 80, 100, 10000).should be_within(1e-10).of(@ruby.cdf(k, 80, 100, 10000))
-      end
-      #result = RubyProf.stop
-      
+        # [2].each do |k|
+        [0, 1, 2, 4, 8, 16].each do |k|
+          expect(@engine.cdf(k, 80, 100, 10_000)).to be_within(1e-10).of(@ruby.cdf(k, 80, 100, 10_000))
+        end
+      # result = RubyProf.stop
+
       # Print a flat profile to text
-      #printer = RubyProf::FlatPrinter.new(result)
-      #printer.print(STDOUT)
-        
+      # printer = RubyProf::FlatPrinter.new(result)
+      # printer.print(STDOUT)
+
       else
         pending("No #{@engine}.pdf")
       end
     end
-    
   end
   describe Distribution::Hypergeometric::Ruby_ do
-    
     before do
-      @engine=Distribution::Hypergeometric::Ruby_
+      @engine = Distribution::Hypergeometric::Ruby_
     end
-    it_only_with_gsl "pdf_fast should return same as pdf" do
+    it_only_with_gsl 'pdf_fast should return same as pdf' do
       pending("Aprox. factorial doesn't work right")
       if @engine.respond_to? :pdf
-        [0,1,2,4,8,16].each do |k|
-          @engine.pdf_aprox(k, 80, 100, 1000).should be_within(1e-8).of(GSL::Ran::hypergeometric_pdf(k, 80, 920, 100))
+        [0, 1, 2, 4, 8, 16].each do |k|
+          expect(@engine.pdf_aprox(k, 80, 100, 1000)).to be_within(1e-8).of(GSL::Ran.hypergeometric_pdf(k, 80, 920, 100))
         end
       else
         pending("No #{@engine}.pdf")
       end
     end
-  
-    it_only_with_gsl "should return correct pdf" do
-      #RubyProf.start
-      
+
+    it_only_with_gsl 'should return correct pdf' do
+      # RubyProf.start
+
       if @engine.respond_to? :pdf
-        #[2].each do |k|
-        [0,1,2,4,8,16].each do |k|
-          #puts "k:#{k}->#{@engine.pdf(k, 80, 100, 10000).to_f}"
-          @engine.pdf(k, 80, 100, 10000).to_f.should be_within(1e-8).of(GSL::Ran::hypergeometric_pdf(k, 80, 9920, 100))
-      end
-      #result = RubyProf.stop
-      
+        # [2].each do |k|
+        [0, 1, 2, 4, 8, 16].each do |k|
+          # puts "k:#{k}->#{@engine.pdf(k, 80, 100, 10000).to_f}"
+          expect(@engine.pdf(k, 80, 100, 10_000).to_f).to be_within(1e-8).of(GSL::Ran.hypergeometric_pdf(k, 80, 9920, 100))
+        end
+      # result = RubyProf.stop
+
       # Print a flat profile to text
-      #printer = RubyProf::FlatPrinter.new(result)
-      #printer.print(STDOUT)
-        
+      # printer = RubyProf::FlatPrinter.new(result)
+      # printer.print(STDOUT)
+
       else
         pending("No #{@engine}.pdf")
       end
     end
-    
-    
-    
-    
-    it "should return correct cdf" do
-      total=rand(5)+3000
-      n=rand(10)+15
-      m=rand(10)+5
-      ac=0
-      0.upto(m) do |i| 
-        ac+=@engine.pdf(i,m,n,total)
-        @engine.cdf(i,m,n,total).should eq(ac)
+
+    it 'should return correct cdf' do
+      total = rand(5) + 3000
+      n = rand(10) + 15
+      m = rand(10) + 5
+      ac = 0
+      0.upto(m) do |i|
+        ac += @engine.pdf(i, m, n, total)
+        expect(@engine.cdf(i, m, n, total)).to eq(ac)
       end
     end
-    
-    it "should return correct p_value" do
-      #0.upto(10) do |i|
+
+    it 'should return correct p_value' do
+      # 0.upto(10) do |i|
       #  puts "#{i}:#{@engine.pdf(i,5,7,10)}"
-      #end
-      total=rand(5)+3000
-      n=rand(10)+15
-      m=rand(10)+5
-      ac=0
+      # end
+      total = rand(5) + 3000
+      n = rand(10) + 15
+      m = rand(10) + 5
+      ac = 0
       0.upto(m) do |k|
-        ac+=@engine.pdf(k,m,n,total)
-        @engine.p_value(ac, m, n, total).should eq(k)
+        ac += @engine.pdf(k, m, n, total)
+        expect(@engine.p_value(ac, m, n, total)).to eq(k)
       end
-    end    
+    end
   end
   describe Distribution::Hypergeometric do
     before do
-      @engine=Distribution::Hypergeometric
+      @engine = Distribution::Hypergeometric
     end
-    it {@engine.should respond_to(:exact_pdf) }
-    it {@engine.should respond_to(:exact_cdf) }
-    it {@engine.should respond_to(:exact_p_value) }
-    it "exact pdf should return a Rational" do
-      @engine.exact_pdf(1,1,1,1).should_not be_a(Float)
-      @engine.exact_pdf(16, 80, 100, 10000).should_not be_a(Float)
+    it { expect(@engine).to respond_to(:exact_pdf) }
+    it { expect(@engine).to respond_to(:exact_cdf) }
+    it { expect(@engine).to respond_to(:exact_p_value) }
+    it 'exact pdf should return a Rational' do
+      expect(@engine.exact_pdf(1, 1, 1, 1)).not_to be_a(Float)
+      expect(@engine.exact_pdf(16, 80, 100, 10_000)).not_to be_a(Float)
     end
-
   end
-end
+end

data/spec/logistic_spec.rb

@@ -1,68 +1,62 @@
-require File.expand_path(File.dirname(__FILE__)+"/spec_helper.rb")
-  
+require File.expand_path(File.dirname(__FILE__) + '/spec_helper.rb')
+
 describe Distribution::Logistic do
-    
-  shared_examples_for "logistic engine" do
-    it "should return correct pdf" do
+  shared_examples_for 'logistic engine' do
+    it 'should return correct pdf' do
       if @engine.respond_to? :pdf
         1.upto(10) {
-	u=rand()
-        s=rand()+1
-        x=rand()*100-50
-        exp=Math.exp(-(x-u) / s) / (s*(1+Math.exp(-(x-u) / s)**2))
-        @engine.pdf(x,u,s).should eq(exp)
+          u = rand
+          s = rand + 1
+          x = rand * 100 - 50
+          exp = Math.exp(-(x - u) / s) / (s * (1 + Math.exp(-(x - u) / s)**2))
+          expect(@engine.pdf(x, u, s)).to eq(exp)
         }
       else
         pending("No #{@engine}.pdf")
        end
     end
-    
-    it "should return correct cdf" do
-      if @engine.respond_to? :cdf
-
 
+    it 'should return correct cdf' do
+      if @engine.respond_to? :cdf
         1.upto(100) {
-	u=rand()
-        s=rand()+1
-        x=rand()*100-50
-	exp=1/(1+Math.exp(-(x-u)/s))
-	@engine.cdf(x,u,s).should eq(exp)
+          u = rand
+          s = rand * 100
+          x = rand * 100 - 50
+          exp = 1 / (1 + Math.exp(-(x - u) / s))
+
+          expect(@engine.cdf(x, u, s)).to eq(exp)
         }
-      
+
       else
         pending("No #{@engine}.cdf")
       end
     end
-  
-    
-    it "should return correct p_value" do
+
+    it 'should return correct p_value' do
       if @engine.respond_to? :p_value
-       1.upto(9) {|i|
-       u=rand()
-       s=rand()+1
-       x=@engine.p_value(i/10,u,s)
-       @engine.cdf(x,u,s).should eq i/10
+        1.upto(9) {|i|
+          u = rand
+          s = rand * 100
+          x = @engine.p_value(i / 10.0, u, s)
+          expect(@engine.cdf(x, u, s)).to be_within(1e-10).of(i / 10.0)
         }
       else
         pending("No #{@engine}.cdf")
       end
     end
   end
-  
 
-  describe "singleton" do
+  describe 'singleton' do
     before do
-      @engine=Distribution::Logistic
+      @engine = Distribution::Logistic
     end
-    it_should_behave_like "logistic engine"
+    it_should_behave_like 'logistic engine'
   end
-  
+
   describe Distribution::Logistic::Ruby_ do
     before do
-      @engine=Distribution::Logistic::Ruby_
+      @engine = Distribution::Logistic::Ruby_
     end
-    it_should_behave_like "logistic engine"
-    
+    it_should_behave_like 'logistic engine'
   end
-    
 end

data/spec/lognormal_spec.rb

@@ -0,0 +1,54 @@
+require File.expand_path(File.dirname(__FILE__) + '/spec_helper.rb')
+
+describe Distribution::LogNormal do
+  shared_examples_for 'log-normal engine' do
+    it 'should return correct pdf' do
+      if @engine.respond_to? :pdf
+        1.upto(10) {
+          u = rand
+          s = rand * 100
+          x = rand * 50
+          exp = (1.0 / (x * s * Math.sqrt(2 * Math::PI))) * Math.exp(-((Math.log(x) - u)**2 / (2 * s**2)))
+          expect(@engine.pdf(x, u, s)).to be_within(1e-10).of(exp)
+        }
+      else
+        pending("No #{@engine}.pdf")
+       end
+    end
+    it 'should return correct cdf' do
+      if @engine.respond_to? :cdf
+        1.upto(10) {
+          u = rand
+          s = rand * 100
+          x = rand * 50
+          exp = Distribution::Normal.cdf((Math.log(x) - u) / s)
+          expect(@engine.cdf(x, u, s)).to be_within(1e-10).of(exp)
+        }
+      else
+        pending("No #{@engine}.cdf")
+       end
+    end
+  end
+
+  describe 'singleton' do
+    before do
+      @engine = Distribution::LogNormal
+    end
+    it_should_behave_like 'log-normal engine'
+  end
+
+  describe Distribution::LogNormal::Ruby_ do
+    before do
+      @engine = Distribution::LogNormal::Ruby_
+    end
+    it_should_behave_like 'log-normal engine'
+  end
+  if Distribution.has_gsl?
+    describe Distribution::LogNormal::GSL_ do
+      before do
+        @engine = Distribution::LogNormal::GSL_
+      end
+      it_should_behave_like 'log-normal engine'
+    end
+  end
+end