distribution 0.7.3 → 0.8.0

data/spec/exponential_spec.rb

@@ -1,39 +1,37 @@
-require File.expand_path(File.dirname(__FILE__)+"/spec_helper.rb")
-  
+require File.expand_path(File.dirname(__FILE__) + '/spec_helper.rb')
+
 describe Distribution::Exponential do
-  
-  shared_examples_for "exponential engine" do
-    it "should return correct pdf" do
+  shared_examples_for 'exponential engine' do
+    it 'should return correct pdf' do
       if @engine.respond_to? :pdf
-        [0.5,1,1.5].each {|l|
+        [0.5, 1, 1.5].each {|l|
           1.upto(5) {|x|
-            @engine.pdf(x,l).should be_within(1e-10).of(l*Math.exp(-l*x))
+            expect(@engine.pdf(x, l)).to be_within(1e-10).of(l * Math.exp(-l * x))
           }
         }
       else
         pending("No #{@engine}.pdf")
       end
     end
-    
-    it "should return correct cdf" do
+
+    it 'should return correct cdf' do
       if @engine.respond_to? :cdf
-        [0.5,1,1.5].each {|l|
+        [0.5, 1, 1.5].each {|l|
           1.upto(5) {|x|
-            @engine.cdf(x,l).should be_within(1e-10).of(1-Math.exp(-l*x))
+            expect(@engine.cdf(x, l)).to be_within(1e-10).of(1 - Math.exp(-l * x))
           }
         }
       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
-        [0.5,1,1.5].each {|l|
+        [0.5, 1, 1.5].each {|l|
           1.upto(5) {|x|
-            pr=@engine.cdf(x,l)
-            @engine.p_value(pr,l).should be_within(1e-10).of(x)
+            pr = @engine.cdf(x, l)
+            expect(@engine.p_value(pr, l)).to be_within(1e-10).of(x)
           }
         }
       else
@@ -41,54 +39,51 @@ describe Distribution::Exponential do
       end
     end
   end
-  
 
-  describe "singleton" do
+  describe 'singleton' do
     before do
-      @engine=Distribution::Exponential
+      @engine = Distribution::Exponential
     end
-    it_should_behave_like "exponential engine"
+    it_should_behave_like 'exponential engine'
   end
-  
+
   describe Distribution::Exponential::Ruby_ do
     before do
-      @engine=Distribution::Exponential::Ruby_
+      @engine = Distribution::Exponential::Ruby_
     end
-    it_should_behave_like "exponential engine"
-    
+    it_should_behave_like 'exponential engine'
   end
-    
+
   if Distribution.has_gsl?
     describe Distribution::Exponential::GSL_ do
       before do
-        @engine=Distribution::Exponential::GSL_
+        @engine = Distribution::Exponential::GSL_
       end
-    it_should_behave_like "exponential engine"
+      it_should_behave_like 'exponential engine'
     end
   end
-  
-#  if Distribution.has_java?
-#    describe Distribution::Exponential::Java_ do
-#      before do
-#        @engine=Distribution::Exponential::Java_
-#      end
-#    it_should_behave_like "exponential engine"
-#    
-#    end  
-#  end
-  describe "rng" do
-    it "should default to Kernel#rand if no :random is given" do
-      Random.stub(:rand)
-      Random.should_receive(:rand).and_return(0.5)
+
+  #  if Distribution.has_java?
+  #    describe Distribution::Exponential::Java_ do
+  #      before do
+  #        @engine=Distribution::Exponential::Java_
+  #      end
+  #    it_should_behave_like "exponential engine"
+  #
+  #    end
+  #  end
+  describe 'rng' do
+    it 'should default to Kernel#rand if no :random is given' do
+      allow(Random).to receive(:rand).and_return(0.5)
       rng = Distribution::Exponential.rng 1.0
-      rng.call()
+      rng.call
     end
 
-    it "should use a given rng if one is passed during construction" do
-      random = double("random")
-      random.should_receive(:rand).and_return(0.5)
-      rng = Distribution::Exponential::rng 1.0, :random => random
-      rng.call()
+    it 'should use a given rng if one is passed during construction' do
+      random = double('random')
+      allow(random).to receive(:rand).and_return(0.5)
+      rng = Distribution::Exponential.rng 1.0, random: random
+      rng.call
     end
-  end  
+  end
 end

data/spec/f_spec.rb

@@ -15,7 +15,7 @@ describe Distribution::F do
         [0.1, 0.5, 1, 2, 10, 20, 30].each do |x|
           [2, 5, 10].product([2, 5, 10]).each do |n, m|
             expected_value = GSL::Ran.fdist_pdf(x, n, m)
-            @engine.pdf(x, n, m).should be_within(1e-4).of(expected_value)
+            expect(@engine.pdf(x, n, m)).to be_within(1e-4).of(expected_value)
           end
         end
       else
@@ -30,7 +30,7 @@ describe Distribution::F do
         [0.1, 0.5, 1, 2, 10, 20, 30].each do |f|
           [2, 5, 10].each do |n2|
             [2, 5, 10].each do |n1|
-              @engine.cdf(f, n1, n2).should be_within(1e-4).of(GSL::Cdf.fdist_P(f, n1, n2))
+              expect(@engine.cdf(f, n1, n2)).to be_within(1e-4).of(GSL::Cdf.fdist_P(f, n1, n2))
             end
           end
         end
@@ -43,7 +43,7 @@ describe Distribution::F do
       if @engine.respond_to? :p_value
 
         expected_value = GSL::Cdf.fdist_Pinv(0.975, 5, 4.189092917592713)
-        @engine.p_value(0.975, 5, 4.189092917592713).should be_within(1e-4).of(expected_value)
+        expect(@engine.p_value(0.975, 5, 4.189092917592713)).to be_within(1e-4).of(expected_value)
 
         [0.1, 0.5, 1, 2, 10, 20, 30].each do |f|
           [2, 5, 10].each do |n2|
@@ -51,7 +51,7 @@ describe Distribution::F do
               area = @engine.cdf(f, n1, n2)
               expected_value = GSL::Cdf.fdist_Pinv(area, n1, n2)
 
-              @engine.p_value(area, n1, n2).should be_within(1e-4).of(expected_value)
+              expect(@engine.p_value(area, n1, n2)).to be_within(1e-4).of(expected_value)
             end
           end
         end

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
-      skip("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