statsample 1.4.1 → 1.4.2

data/test/test_factor_pa.rb

@@ -1,52 +1,52 @@
-require(File.expand_path(File.dirname(__FILE__)+'/helpers_tests.rb'))
-#require 'rserve'
-#require 'statsample/rserve_extension'
+require(File.expand_path(File.dirname(__FILE__) + '/helpers_tests.rb'))
+# require 'rserve'
+# require 'statsample/rserve_extension'
 
-class StatsampleFactorTestCase < MiniTest::Unit::TestCase
+class StatsampleFactorTestCase < Minitest::Test
   include Statsample::Fixtures
   # Based on Hardle and Simar
   def setup
-    @fixtures_dir=File.expand_path(File.dirname(__FILE__)+"/fixtures")
+    @fixtures_dir = File.expand_path(File.dirname(__FILE__) + '/fixtures')
   end
+
   def test_parallelanalysis_with_data
     if Statsample.has_gsl?
-      samples=100
-      variables=10
-      iterations=50
+      samples = 100
+      variables = 10
+      iterations = 50
       rng = Distribution::Normal.rng
-      f1=samples.times.collect {rng.call}.to_scale
-      f2=samples.times.collect {rng.call}.to_scale    
-      vectors={}
+      f1 = samples.times.collect { rng.call }.to_scale
+      f2 = samples.times.collect { rng.call }.to_scale
+      vectors = {}
       variables.times do |i|
-        if i<5
-          vectors["v#{i}"]=samples.times.collect {|nv|
-            f1[nv]*5+f2[nv]*2+rng.call
+        if i < 5
+          vectors["v#{i}"] = samples.times.collect {|nv|
+            f1[nv] * 5 + f2[nv] * 2 + rng.call
           }.to_scale
         else
-          vectors["v#{i}"]=samples.times.collect {|nv|
-            f2[nv]*5+f1[nv]*2+rng.call
+          vectors["v#{i}"] = samples.times.collect {|nv|
+            f2[nv] * 5 + f1[nv] * 2 + rng.call
           }.to_scale
         end
-        
       end
-      ds=vectors.to_dataset
-      
-      pa1=Statsample::Factor::ParallelAnalysis.new(ds, :bootstrap_method=>:data, :iterations=>iterations)
-      pa2=Statsample::Factor::ParallelAnalysis.with_random_data(samples,variables,:iterations=>iterations,:percentil=>95)
+      ds = vectors.to_dataset
+
+      pa1 = Statsample::Factor::ParallelAnalysis.new(ds, bootstrap_method: :data, iterations: iterations)
+      pa2 = Statsample::Factor::ParallelAnalysis.with_random_data(samples, variables, iterations: iterations, percentil: 95)
       3.times do |n|
-        var="ev_0000#{n+1}"
-        assert_in_delta(pa1.ds_eigenvalues[var].mean, pa2.ds_eigenvalues[var].mean,0.05)
+        var = "ev_0000#{n + 1}"
+        assert_in_delta(pa1.ds_eigenvalues[var].mean, pa2.ds_eigenvalues[var].mean, 0.05)
       end
     else
-      skip("Too slow without GSL")
+      skip('Too slow without GSL')
     end
-    
   end
+
   def test_parallelanalysis
-    pa=Statsample::Factor::ParallelAnalysis.with_random_data(305,8,:iterations=>100,:percentil=>95)
+    pa = Statsample::Factor::ParallelAnalysis.with_random_data(305, 8, iterations: 100, percentil: 95)
     assert_in_delta(1.2454, pa.ds_eigenvalues['ev_00001'].mean, 0.01)
     assert_in_delta(1.1542, pa.ds_eigenvalues['ev_00002'].mean, 0.01)
     assert_in_delta(1.0836, pa.ds_eigenvalues['ev_00003'].mean, 0.01)
-    assert(pa.summary.size>0)
-  end  
+    assert(pa.summary.size > 0)
+  end
 end

data/test/test_ggobi.rb

@@ -1,24 +1,25 @@
-require(File.expand_path(File.dirname(__FILE__)+'/helpers_tests.rb'))
+require(File.expand_path(File.dirname(__FILE__) + '/helpers_tests.rb'))
 require 'ostruct'
-class StatsampleGGobiTestCase < MiniTest::Unit::TestCase
-
+class StatsampleGGobiTestCase < Minitest::Test
   def setup
-    v1=([10.2,20.3,10,20,30,40,30,20,30,40]*10).to_vector(:scale)
-    @v2=(%w{a b c a a a b b c d}*10).to_vector(:nominal)
-    @v2.labels={"a"=>"letter a","d"=>"letter d"}
-    v3=([1,2,3,4,5,4,3,2,1,2]*10).to_vector(:ordinal)
-    @ds={'v1'=>v1,'v2'=>@v2,'v3'=>v3}.to_dataset
+    v1 = ([10.2, 20.3, 10, 20, 30, 40, 30, 20, 30, 40] * 10).to_vector(:scale)
+    @v2 = (%w(a b c a a a b b c d) * 10).to_vector(:nominal)
+    @v2.labels = { 'a' => 'letter a', 'd' => 'letter d' }
+    v3 = ([1, 2, 3, 4, 5, 4, 3, 2, 1, 2] * 10).to_vector(:ordinal)
+    @ds = { 'v1' => v1, 'v2' => @v2, 'v3' => v3 }.to_dataset
   end
+
   def test_values_definition
-    a=[1.0,2,"a",nil]
-    assert_equal("1.0 2 a NA", Statsample::GGobi.values_definition(a,"NA"))
+    a = [1.0, 2, 'a', nil]
+    assert_equal('1.0 2 a NA', Statsample::GGobi.values_definition(a, 'NA'))
   end
+
   def test_variable_definition
-    carrier=OpenStruct.new
-    carrier.categorials=[]
-    carrier.conversions={}
-    real_var_definition=Statsample::GGobi.variable_definition(carrier,@v2,'variable 2',"v2")
-		expected=<<-EOS
+    carrier = OpenStruct.new
+    carrier.categorials = []
+    carrier.conversions = {}
+    real_var_definition = Statsample::GGobi.variable_definition(carrier, @v2, 'variable 2', 'v2')
+    expected = <<-EOS
 <categoricalvariable name="variable 2" nickname="v2">
 <levels count="4">
 <level value="1">letter a</level>
@@ -27,8 +28,8 @@ class StatsampleGGobiTestCase < MiniTest::Unit::TestCase
 <level value="4">letter d</level></levels>
 </categoricalvariable>
     EOS
-    assert_equal(expected.gsub(/\s/," "),real_var_definition.gsub(/\s/," "))
-    assert_equal({'variable 2'=>{'a'=>1,'b'=>2,'c'=>3,'d'=>4}},carrier.conversions)
-    assert_equal(['variable 2'],carrier.categorials)
+    assert_equal(expected.gsub(/\s/, ' '), real_var_definition.gsub(/\s/, ' '))
+    assert_equal({ 'variable 2' => { 'a' => 1, 'b' => 2, 'c' => 3, 'd' => 4 } }, carrier.conversions)
+    assert_equal(['variable 2'], carrier.categorials)
   end
 end

data/test/test_gsl.rb

@@ -1,17 +1,15 @@
-require(File.expand_path(File.dirname(__FILE__)+'/helpers_tests.rb'))
-class StatsampleGSLTestCase < MiniTest::Unit::TestCase
-  should_with_gsl "matrix with gsl" do
-    a=[1,2,3,4,20].to_vector(:scale)
-    b=[3,2,3,4,50].to_vector(:scale)
-    c=[6,2,3,4,3].to_vector(:scale)
-    ds={'a'=>a,'b'=>b,'c'=>c}.to_dataset
-    gsl=ds.to_matrix.to_gsl
-    assert_equal(5,gsl.size1)
-    assert_equal(3,gsl.size2)
-    matrix=gsl.to_matrix
-    assert_equal(5,matrix.row_size)
-    assert_equal(3,matrix.column_size)
+require(File.expand_path(File.dirname(__FILE__) + '/helpers_tests.rb'))
+class StatsampleGSLTestCase < Minitest::Test
+  should_with_gsl 'matrix with gsl' do
+    a = [1, 2, 3, 4, 20].to_vector(:scale)
+    b = [3, 2, 3, 4, 50].to_vector(:scale)
+    c = [6, 2, 3, 4, 3].to_vector(:scale)
+    ds = { 'a' => a, 'b' => b, 'c' => c }.to_dataset
+    gsl = ds.to_matrix.to_gsl
+    assert_equal(5, gsl.size1)
+    assert_equal(3, gsl.size2)
+    matrix = gsl.to_matrix
+    assert_equal(5, matrix.row_size)
+    assert_equal(3, matrix.column_size)
   end
 end
-
-

data/test/test_histogram.rb

@@ -1,112 +1,109 @@
-require(File.expand_path(File.dirname(__FILE__)+'/helpers_tests.rb'))
+require(File.expand_path(File.dirname(__FILE__) + '/helpers_tests.rb'))
 
-
-class StatsampleHistogramTestCase < MiniTest::Unit::TestCase
+class StatsampleHistogramTestCase < Minitest::Test
   context Statsample::Histogram do
-    should "alloc correctly with integer" do
+    should 'alloc correctly with integer' do
       h = Statsample::Histogram.alloc(4)
-      assert_equal([0.0]*4, h.bin)
-      assert_equal([0.0]*5, h.range)
+      assert_equal([0.0] * 4, h.bin)
+      assert_equal([0.0] * 5, h.range)
     end
-    should "alloc correctly with array" do
+    should 'alloc correctly with array' do
       h = Statsample::Histogram.alloc([1, 3, 7, 9, 20])
-      assert_equal([0.0]*4, h.bin)
-      assert_equal([1,3,7,9,20], h.range)
+      assert_equal([0.0] * 4, h.bin)
+      assert_equal([1, 3, 7, 9, 20], h.range)
     end
-    should "alloc correctly with integer and min, max array" do
+    should 'alloc correctly with integer and min, max array' do
       h = Statsample::Histogram.alloc(5, [0, 5])
-      assert_equal([0.0,1.0,2.0,3.0,4.0,5.0], h.range)
-      assert_equal([0.0]*5,h.bin)
+      assert_equal([0.0, 1.0, 2.0, 3.0, 4.0, 5.0], h.range)
+      assert_equal([0.0] * 5, h.bin)
     end
-    should "bin() method return correct number of bins" do
+    should 'bin() method return correct number of bins' do
       h = Statsample::Histogram.alloc(4)
-      assert_equal(4,h.bins)
+      assert_equal(4, h.bins)
     end
-    should "increment correctly" do 
-      h = Statsample::Histogram.alloc(5, [0, 5])      
+    should 'increment correctly' do
+      h = Statsample::Histogram.alloc(5, [0, 5])
       h.increment 2.5
-      assert_equal([0.0,0.0,1.0,0.0,0.0], h.bin)
-      h.increment [0.5,0.5,3.5,3.5]
-      assert_equal([2.0,0.0,1.0,2.0,0.0], h.bin)
+      assert_equal([0.0, 0.0, 1.0, 0.0, 0.0], h.bin)
+      h.increment [0.5, 0.5, 3.5, 3.5]
+      assert_equal([2.0, 0.0, 1.0, 2.0, 0.0], h.bin)
       h.increment 0
-      assert_equal([3.0,0.0,1.0,2.0,0.0], h.bin)
+      assert_equal([3.0, 0.0, 1.0, 2.0, 0.0], h.bin)
       h.increment 5
-      assert_equal([3.0,0.0,1.0,2.0,0.0], h.bin)
+      assert_equal([3.0, 0.0, 1.0, 2.0, 0.0], h.bin)
     end
-    
-    should "alloc_uniform correctly with n, min,max" do
-      h = Statsample::Histogram.alloc_uniform(5,0,10)
-      assert_equal(5,h.bins)
-      assert_equal([0.0]*5,h.bin)
-      assert_equal([0.0,2.0,4.0,6.0,8.0,10.0], h.range)
+
+    should 'alloc_uniform correctly with n, min,max' do
+      h = Statsample::Histogram.alloc_uniform(5, 0, 10)
+      assert_equal(5, h.bins)
+      assert_equal([0.0] * 5, h.bin)
+      assert_equal([0.0, 2.0, 4.0, 6.0, 8.0, 10.0], h.range)
     end
-    should "alloc_uniform correctly with n, [min,max]" do
+    should 'alloc_uniform correctly with n, [min,max]' do
       h = Statsample::Histogram.alloc_uniform(5, [0, 10])
-      assert_equal(5,h.bins)
-      assert_equal([0.0]*5,h.bin)
-      assert_equal([0.0,2.0,4.0,6.0,8.0,10.0], h.range)
+      assert_equal(5, h.bins)
+      assert_equal([0.0] * 5, h.bin)
+      assert_equal([0.0, 2.0, 4.0, 6.0, 8.0, 10.0], h.range)
     end
-    should "get_range()" do
-      h = Statsample::Histogram.alloc_uniform(5,2,12)
+    should 'get_range()' do
+      h = Statsample::Histogram.alloc_uniform(5, 2, 12)
       5.times {|i|
-        assert_equal([2+i*2, 4+i*2], h.get_range(i))
+        assert_equal([2 + i * 2, 4 + i * 2], h.get_range(i))
+      }
+    end
+    should 'min() and max()' do
+      h = Statsample::Histogram.alloc_uniform(5, 2, 12)
+      assert_equal(2, h.min)
+      assert_equal(12, h.max)
+    end
+    should 'max_val()' do
+      h = Statsample::Histogram.alloc(5, [0, 5])
+      100.times { h.increment(rand * 5) }
+      max = h.bin[0]
+      (1..4).each {|i|
+        max = h.bin[i] if h.bin[i] > max
       }
+      assert_equal(max, h.max_val)
     end
-    should "min() and max()" do
-      h=Statsample::Histogram.alloc_uniform(5,2,12)
-      assert_equal(2,h.min)
-      assert_equal(12,h.max)
-    end
-    should "max_val()" do
-       h = Statsample::Histogram.alloc(5, [0, 5])
-       100.times {h.increment(rand*5)}
-       max=h.bin[0]
-       (1..4).each {|i|
-         max = h.bin[i] if h.bin[i] > max
-       }
-       assert_equal(max,h.max_val)
-    end
-    should "min_val()" do
-       h = Statsample::Histogram.alloc(5, [0, 5])
-       100.times {h.increment(rand*5)}
-       min=h.bin[0]
-       (1..4).each {|i|
-         min = h.bin[i] if h.bin[i]<min
-       }
-       assert_equal(min,h.min_val)
-    end
-    should "return correct estimated mean" do
-      a=[1.5,1.5,1.5,3.5,3.5,3.5].to_scale
-      h=Statsample::Histogram.alloc(5,[0,5])
+    should 'min_val()' do
+      h = Statsample::Histogram.alloc(5, [0, 5])
+      100.times { h.increment(rand * 5) }
+      min = h.bin[0]
+      (1..4).each {|i|
+        min = h.bin[i] if h.bin[i] < min
+      }
+      assert_equal(min, h.min_val)
+    end
+    should 'return correct estimated mean' do
+      a = [1.5, 1.5, 1.5, 3.5, 3.5, 3.5].to_scale
+      h = Statsample::Histogram.alloc(5, [0, 5])
       h.increment(a)
       assert_equal(2.5, h.estimated_mean)
     end
-    should "return correct estimated standard deviation" do
-      a=[0.5,1.5,1.5,1.5,2.5, 3.5,3.5,3.5,4.5].to_scale
-      h=Statsample::Histogram.alloc(5,[0,5])
+    should 'return correct estimated standard deviation' do
+      a = [0.5, 1.5, 1.5, 1.5, 2.5, 3.5, 3.5, 3.5, 4.5].to_scale
+      h = Statsample::Histogram.alloc(5, [0, 5])
       h.increment(a)
       assert_equal(a.sd, h.estimated_standard_deviation)
     end
-    should "return correct sum for all values" do
-      h=Statsample::Histogram.alloc(5,[0,5])
-      n=rand(100)
-      n.times { h.increment(1)}
+    should 'return correct sum for all values' do
+      h = Statsample::Histogram.alloc(5, [0, 5])
+      n = rand(100)
+      n.times { h.increment(1) }
       assert_equal(n, h.sum)
     end
-    should "return correct sum for a subset of values" do
-      h=Statsample::Histogram.alloc(5,[0,5])
-      h.increment([0.5,2.5,4.5])
-      assert_equal(1,h.sum(0,1))
-      assert_equal(2,h.sum(1,4))
-
+    should 'return correct sum for a subset of values' do
+      h = Statsample::Histogram.alloc(5, [0, 5])
+      h.increment([0.5, 2.5, 4.5])
+      assert_equal(1, h.sum(0, 1))
+      assert_equal(2, h.sum(1, 4))
     end
-    should "not raise exception when all values equal" do
+    should 'not raise exception when all values equal' do
       assert_nothing_raised do
-        a = [5,5,5,5,5,5].to_scale
-        h=Statsample::Graph::Histogram.new(a)
+        a = [5, 5, 5, 5, 5, 5].to_scale
+        h = Statsample::Graph::Histogram.new(a)
         h.to_svg
       end
     end
-    
   end
 end

data/test/test_matrix.rb

@@ -1,50 +1,48 @@
-require(File.expand_path(File.dirname(__FILE__)+'/helpers_tests.rb'))
+require(File.expand_path(File.dirname(__FILE__) + '/helpers_tests.rb'))
 
-class StatsampleMatrixTestCase < MiniTest::Unit::TestCase
-  
+class StatsampleMatrixTestCase < Minitest::Test
   def test_to_dataset
-    m=Matrix[[1,4],[2,5],[3,6]]
+    m = Matrix[[1, 4], [2, 5], [3, 6]]
     m.extend Statsample::NamedMatrix
-    m.fields_y=%w{x1 x2}
-    m.name="test"
-    samples=100
-    x1=[1,2,3].to_scale
-    x2=[4,5,6].to_scale
-    ds={'x1'=>x1,'x2'=>x2}.to_dataset
-    ds.name="test"
-    obs=m.to_dataset
-    assert_equal(ds['x1'],obs['x1'])
-    assert_equal(ds['x2'],obs['x2'])
-    assert_equal(ds['x1'].mean,obs['x1'].mean)
-    
-    
+    m.fields_y = %w(x1 x2)
+    m.name = 'test'
+    samples = 100
+    x1 = [1, 2, 3].to_scale
+    x2 = [4, 5, 6].to_scale
+    ds = { 'x1' => x1, 'x2' => x2 }.to_dataset
+    ds.name = 'test'
+    obs = m.to_dataset
+    assert_equal(ds['x1'], obs['x1'])
+    assert_equal(ds['x2'], obs['x2'])
+    assert_equal(ds['x1'].mean, obs['x1'].mean)
   end
+
   def test_covariate
-    a=Matrix[[1.0, 0.3, 0.2], [0.3, 1.0, 0.5], [0.2, 0.5, 1.0]]
+    a = Matrix[[1.0, 0.3, 0.2], [0.3, 1.0, 0.5], [0.2, 0.5, 1.0]]
     a.extend Statsample::CovariateMatrix
-    a.fields=%w{a b c}
+    a.fields = %w(a b c)
     assert_equal(:correlation, a._type)
 
-    assert_equal(Matrix[[0.5],[0.3]], a.submatrix(%w{c a}, %w{b}))
-    assert_equal(Matrix[[1.0, 0.2] , [0.2, 1.0]], a.submatrix(%w{c a}))
-    assert_equal(:correlation, a.submatrix(%w{c a})._type)
+    assert_equal(Matrix[[0.5], [0.3]], a.submatrix(%w(c a), %w(b)))
+    assert_equal(Matrix[[1.0, 0.2], [0.2, 1.0]], a.submatrix(%w(c a)))
+    assert_equal(:correlation, a.submatrix(%w(c a))._type)
 
-    a=Matrix[[20,30,10], [30,60,50], [10,50,50]]
+    a = Matrix[[20, 30, 10], [30, 60, 50], [10, 50, 50]]
 
     a.extend Statsample::CovariateMatrix
 
     assert_equal(:covariance, a._type)
 
-    a=50.times.collect {rand()}.to_scale
-    b=50.times.collect {rand()}.to_scale
-    c=50.times.collect {rand()}.to_scale
-    ds={'a'=>a,'b'=>b,'c'=>c}.to_dataset
-    corr=Statsample::Bivariate.correlation_matrix(ds)
-    real=Statsample::Bivariate.covariance_matrix(ds).correlation
+    a = 50.times.collect { rand }.to_scale
+    b = 50.times.collect { rand }.to_scale
+    c = 50.times.collect { rand }.to_scale
+    ds = { 'a' => a, 'b' => b, 'c' => c }.to_dataset
+    corr = Statsample::Bivariate.correlation_matrix(ds)
+    real = Statsample::Bivariate.covariance_matrix(ds).correlation
     corr.row_size.times do |i|
       corr.column_size.times do |j|
-        assert_in_delta(corr[i,j], real[i,j],1e-15)
+        assert_in_delta(corr[i, j], real[i, j], 1e-15)
       end
     end
-  end  
+  end
 end

data/test/test_multiset.rb

@@ -1,158 +1,164 @@
-require(File.expand_path(File.dirname(__FILE__)+'/helpers_tests.rb'))
+require(File.expand_path(File.dirname(__FILE__) + '/helpers_tests.rb'))
 
-
-class StatsampleMultisetTestCase < MiniTest::Unit::TestCase
+class StatsampleMultisetTestCase < Minitest::Test
   def setup
-    @x=%w{a a a a b b b b}.to_vector
-    @y=[1,2,3,4,5,6,7,8].to_scale
-    @z=[10,11,12,13,14,15,16,17].to_scale
-    @ds={'x'=>@x,'y'=>@y,'z'=>@z}.to_dataset
-    @ms=@ds.to_multiset_by_split('x')
+    @x = %w(a a a a b b b b).to_vector
+    @y = [1, 2, 3, 4, 5, 6, 7, 8].to_scale
+    @z = [10, 11, 12, 13, 14, 15, 16, 17].to_scale
+    @ds = { 'x' => @x, 'y' => @y, 'z' => @z }.to_dataset
+    @ms = @ds.to_multiset_by_split('x')
   end
+
   def test_creation
-    v1a=[1,2,3,4,5].to_vector
-    v2b=[11,21,31,41,51].to_vector
-    v3c=[21,23,34,45,56].to_vector
-    ds1={'v1'=>v1a,'v2'=>v2b,'v3'=>v3c}.to_dataset
-    v1b=[15,25,35,45,55].to_vector
-    v2b=[11,21,31,41,51].to_vector
-    v3b=[21,23,34,45,56].to_vector
-    ds2={'v1'=>v1b,'v2'=>v2b,'v3'=>v3b}.to_dataset
-    ms=Statsample::Multiset.new(['v1','v2','v3'])
-    ms.add_dataset('ds1',ds1)
-    ms.add_dataset('ds2',ds2)
-    assert_equal(ds1,ms['ds1'])
-    assert_equal(ds2,ms['ds2'])
-    assert_equal(v1a,ms['ds1']['v1'])
-    assert_not_equal(v1b,ms['ds1']['v1'])
-    ds3={'v1'=>v1b,'v2'=>v2b}.to_dataset
+    v1a = [1, 2, 3, 4, 5].to_vector
+    v2b = [11, 21, 31, 41, 51].to_vector
+    v3c = [21, 23, 34, 45, 56].to_vector
+    ds1 = { 'v1' => v1a, 'v2' => v2b, 'v3' => v3c }.to_dataset
+    v1b = [15, 25, 35, 45, 55].to_vector
+    v2b = [11, 21, 31, 41, 51].to_vector
+    v3b = [21, 23, 34, 45, 56].to_vector
+    ds2 = { 'v1' => v1b, 'v2' => v2b, 'v3' => v3b }.to_dataset
+    ms = Statsample::Multiset.new(%w(v1 v2 v3))
+    ms.add_dataset('ds1', ds1)
+    ms.add_dataset('ds2', ds2)
+    assert_equal(ds1, ms['ds1'])
+    assert_equal(ds2, ms['ds2'])
+    assert_equal(v1a, ms['ds1']['v1'])
+    assert_not_equal(v1b, ms['ds1']['v1'])
+    ds3 = { 'v1' => v1b, 'v2' => v2b }.to_dataset
     assert_raise ArgumentError do
       ms.add_dataset(ds3)
     end
   end
+
   def test_creation_empty
-    ms=Statsample::Multiset.new_empty_vectors(%w{id age name},%w{male female})
-    ds_male={'id'=>[].to_vector,'age'=>[].to_vector, 'name'=>[].to_vector}.to_dataset(%w{id age name})
-    ds_female={'id'=>[].to_vector,'age'=>[].to_vector, 'name'=>[].to_vector}.to_dataset(%w{id age name})
-    ms2=Statsample::Multiset.new(%w{id age name})
-    ms2.add_dataset('male',ds_male)
-    ms2.add_dataset('female',ds_female)
-    assert_equal(ms2.fields,ms.fields)
-    assert_equal(ms2['male'],ms['male'])
-    assert_equal(ms2['female'],ms['female'])
+    ms = Statsample::Multiset.new_empty_vectors(%w(id age name), %w(male female))
+    ds_male = { 'id' => [].to_vector, 'age' => [].to_vector, 'name' => [].to_vector }.to_dataset(%w(id age name))
+    ds_female = { 'id' => [].to_vector, 'age' => [].to_vector, 'name' => [].to_vector }.to_dataset(%w(id age name))
+    ms2 = Statsample::Multiset.new(%w(id age name))
+    ms2.add_dataset('male', ds_male)
+    ms2.add_dataset('female', ds_female)
+    assert_equal(ms2.fields, ms.fields)
+    assert_equal(ms2['male'], ms['male'])
+    assert_equal(ms2['female'], ms['female'])
   end
+
   def test_to_multiset_by_split_one
-    sex=%w{m m m m m f f f f m}.to_vector(:nominal)
-    city=%w{London Paris NY London Paris NY London Paris NY Tome}.to_vector(:nominal)
-    age=[10,10,20,30,34,34,33,35,36,40].to_vector(:scale)
-    ds={'sex'=>sex,'city'=>city,'age'=>age}.to_dataset
-    ms=ds.to_multiset_by_split('sex')
-    assert_equal(2,ms.n_datasets)
-    assert_equal(%w{f m},ms.datasets.keys.sort)
-    assert_equal(6,ms['m'].cases)
-    assert_equal(4,ms['f'].cases)
-    assert_equal(%w{London Paris NY London Paris Tome},ms['m']['city'].to_a)
-    assert_equal([34,33,35,36],ms['f']['age'].to_a)
+    sex = %w(m m m m m f f f f m).to_vector(:nominal)
+    city = %w(London Paris NY London Paris NY London Paris NY Tome).to_vector(:nominal)
+    age = [10, 10, 20, 30, 34, 34, 33, 35, 36, 40].to_vector(:scale)
+    ds = { 'sex' => sex, 'city' => city, 'age' => age }.to_dataset
+    ms = ds.to_multiset_by_split('sex')
+    assert_equal(2, ms.n_datasets)
+    assert_equal(%w(f m), ms.datasets.keys.sort)
+    assert_equal(6, ms['m'].cases)
+    assert_equal(4, ms['f'].cases)
+    assert_equal(%w(London Paris NY London Paris Tome), ms['m']['city'].to_a)
+    assert_equal([34, 33, 35, 36], ms['f']['age'].to_a)
   end
+
   def test_to_multiset_by_split_multiple
-    sex=%w{m m m m m m m m m m f f f f f f f f f f}.to_vector(:nominal)
-    city=%w{London London London Paris Paris London London London Paris Paris London London London Paris Paris London London London Paris Paris}.to_vector(:nominal)
-    hair=%w{blonde blonde black black blonde blonde black black blonde blonde black black blonde blonde black black blonde blonde black black}.to_vector(:nominal)
-    age=[10,10,20,30,34,34,33,35,36,40, 10,10,20,30,34,34,33,35,36,40].to_vector(:scale)
-    ds={'sex'=>sex,'city'=>city,'hair'=>hair,'age'=>age}.to_dataset(%w{sex city hair age})
-    ms=ds.to_multiset_by_split('sex','city','hair')
-    assert_equal(8,ms.n_datasets)
-    assert_equal(3,ms[%w{m London blonde}].cases)
-    assert_equal(3,ms[%w{m London blonde}].cases)
-    assert_equal(1,ms[%w{m Paris black}].cases)
+    sex = %w(m m m m m m m m m m f f f f f f f f f f).to_vector(:nominal)
+    city = %w(London London London Paris Paris London London London Paris Paris London London London Paris Paris London London London Paris Paris).to_vector(:nominal)
+    hair = %w(blonde blonde black black blonde blonde black black blonde blonde black black blonde blonde black black blonde blonde black black).to_vector(:nominal)
+    age = [10, 10, 20, 30, 34, 34, 33, 35, 36, 40, 10, 10, 20, 30, 34, 34, 33, 35, 36, 40].to_vector(:scale)
+    ds = { 'sex' => sex, 'city' => city, 'hair' => hair, 'age' => age }.to_dataset(%w(sex city hair age))
+    ms = ds.to_multiset_by_split('sex', 'city', 'hair')
+    assert_equal(8, ms.n_datasets)
+    assert_equal(3, ms[%w(m London blonde)].cases)
+    assert_equal(3, ms[%w(m London blonde)].cases)
+    assert_equal(1, ms[%w(m Paris black)].cases)
   end
 
   def test_stratum_proportion
-    ds1={'q1'=>[1,1,1,1,1,0,0,0,0,0,0,0].to_vector}.to_dataset
-    ds2={'q1'=>[1,1,1,1,1,1,1,0,0].to_vector}.to_dataset
-    assert_equal(5.0/12, ds1['q1'].proportion )
-    assert_equal(7.0/9, ds2['q1'].proportion )
-    ms=Statsample::Multiset.new(['q1'])
-    ms.add_dataset('d1',ds1)
-    ms.add_dataset('d2',ds2)
-    ss=Statsample::StratifiedSample.new(ms,{'d1'=>50,'d2'=>100})
-    assert_in_delta(0.655, ss.proportion('q1'),0.01)
-    assert_in_delta(0.345, ss.proportion('q1',0),0.01)
-
+    ds1 = { 'q1' => [1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0].to_vector }.to_dataset
+    ds2 = { 'q1' => [1, 1, 1, 1, 1, 1, 1, 0, 0].to_vector }.to_dataset
+    assert_equal(5.0 / 12, ds1['q1'].proportion)
+    assert_equal(7.0 / 9, ds2['q1'].proportion)
+    ms = Statsample::Multiset.new(['q1'])
+    ms.add_dataset('d1', ds1)
+    ms.add_dataset('d2', ds2)
+    ss = Statsample::StratifiedSample.new(ms, 'd1' => 50, 'd2' => 100)
+    assert_in_delta(0.655, ss.proportion('q1'), 0.01)
+    assert_in_delta(0.345, ss.proportion('q1', 0), 0.01)
   end
+
   def test_stratum_scale
-    boys={'test'=>[50, 55, 60, 62, 62, 65, 67, 67, 70, 70, 73, 73, 75, 78, 78, 80, 85, 90].to_vector(:scale)}.to_dataset
-    girls={'test'=>[70, 70, 72, 72, 75, 75, 78, 78, 80, 80, 82, 82, 85, 85, 88, 88, 90, 90].to_vector(:scale)}.to_dataset
-    ms=Statsample::Multiset.new(['test'])
-    ms.add_dataset('boys',boys)
-    ms.add_dataset('girls',girls)
-    ss=Statsample::StratifiedSample.new(ms,{'boys'=>10000,'girls'=>10000})
-    assert_equal(2,ss.strata_number)
-    assert_equal(20000,ss.population_size)
-    assert_equal(10000,ss.stratum_size('boys'))
-    assert_equal(10000,ss.stratum_size('girls'))
-    assert_equal(36,ss.sample_size)
-    assert_equal(75,ss.mean('test'))
-    assert_in_delta(1.45,ss.standard_error_wor('test'),0.01)
-    assert_in_delta(ss.standard_error_wor('test'), ss.standard_error_wor_2('test'),0.00001)
+    boys = { 'test' => [50, 55, 60, 62, 62, 65, 67, 67, 70, 70, 73, 73, 75, 78, 78, 80, 85, 90].to_vector(:scale) }.to_dataset
+    girls = { 'test' => [70, 70, 72, 72, 75, 75, 78, 78, 80, 80, 82, 82, 85, 85, 88, 88, 90, 90].to_vector(:scale) }.to_dataset
+    ms = Statsample::Multiset.new(['test'])
+    ms.add_dataset('boys', boys)
+    ms.add_dataset('girls', girls)
+    ss = Statsample::StratifiedSample.new(ms, 'boys' => 10_000, 'girls' => 10_000)
+    assert_equal(2, ss.strata_number)
+    assert_equal(20_000, ss.population_size)
+    assert_equal(10_000, ss.stratum_size('boys'))
+    assert_equal(10_000, ss.stratum_size('girls'))
+    assert_equal(36, ss.sample_size)
+    assert_equal(75, ss.mean('test'))
+    assert_in_delta(1.45, ss.standard_error_wor('test'), 0.01)
+    assert_in_delta(ss.standard_error_wor('test'), ss.standard_error_wor_2('test'), 0.00001)
   end
+
   def test_each
-    xpe={
-      'a'=>%w{a a a a}.to_vector,
-      'b'=>%w{b b b b}.to_vector
+    xpe = {
+      'a' => %w(a a a a).to_vector,
+      'b' => %w(b b b b).to_vector
     }
-    ype={
-      'a'=>[1,2,3,4].to_scale,
-      'b'=>[5,6,7,8].to_scale,
+    ype = {
+      'a' => [1, 2, 3, 4].to_scale,
+      'b' => [5, 6, 7, 8].to_scale
     }
-    zpe={
-      'a'=>[10,11,12,13].to_scale,
-      'b'=>[14,15,16,17].to_scale,
+    zpe = {
+      'a' => [10, 11, 12, 13].to_scale,
+      'b' => [14, 15, 16, 17].to_scale
     }
-    xp,yp,zp=Hash.new(),Hash.new(),Hash.new()
-    @ms.each {|k,ds|
-      xp[k]=ds['x']
-      yp[k]=ds['y']
-      zp[k]=ds['z']
+    xp, yp, zp = {}, {}, {}
+    @ms.each {|k, ds|
+      xp[k] = ds['x']
+      yp[k] = ds['y']
+      zp[k] = ds['z']
     }
-    assert_equal(xpe,xp)
-    assert_equal(ype,yp)
-    assert_equal(zpe,zp)
-
+    assert_equal(xpe, xp)
+    assert_equal(ype, yp)
+    assert_equal(zpe, zp)
   end
+
   def test_multiset_union_with_block
-    
-    r1=rand()
-    r2=rand()
-    ye=[1*r1,2*r1,3*r1,4*r1,5*r2,6*r2,7*r2,8*r2].to_scale
-    
-    ze=[10*r1,11*r1,12*r1,13*r1, 14*r2,15*r2,16*r2,17*r2].to_scale
-    
-    ds2=@ms.union {|k,ds|
-      ds['y'].recode!{|v| 
-      k=='a' ? v*r1 : v*r2}
-      ds['z'].recode!{|v| 
-      k=='a' ? v*r1 : v*r2}
+    r1 = rand
+    r2 = rand
+    ye = [1 * r1, 2 * r1, 3 * r1, 4 * r1, 5 * r2, 6 * r2, 7 * r2, 8 * r2].to_scale
+
+    ze = [10 * r1, 11 * r1, 12 * r1, 13 * r1, 14 * r2, 15 * r2, 16 * r2, 17 * r2].to_scale
+
+    ds2 = @ms.union {|k, ds|
+      ds['y'].recode!{|v|
+        k == 'a' ? v * r1 : v * r2
+      }
+      ds['z'].recode!{|v|
+        k == 'a' ? v * r1 : v * r2
+      }
     }
-    assert_equal(ye,ds2['y'])
-    assert_equal(ze,ds2['z'])
+    assert_equal(ye, ds2['y'])
+    assert_equal(ze, ds2['z'])
   end
+
   def test_multiset_union
-    r1=rand()
-    r2=rand()
-    ye=[1*r1,2*r1,3*r1,4*r1,5*r2,6*r2,7*r2,8*r2].to_scale
-    
-    ze=[10*r1,11*r1,12*r1,13*r1, 14*r2,15*r2,16*r2,17*r2].to_scale
-    @ms.each {|k,ds|
-      ds['y'].recode!{|v| 
-      k=='a' ? v*r1 : v*r2}
-      ds['z'].recode!{|v| 
-      k=='a' ? v*r1 : v*r2}
-      
+    r1 = rand
+    r2 = rand
+    ye = [1 * r1, 2 * r1, 3 * r1, 4 * r1, 5 * r2, 6 * r2, 7 * r2, 8 * r2].to_scale
+
+    ze = [10 * r1, 11 * r1, 12 * r1, 13 * r1, 14 * r2, 15 * r2, 16 * r2, 17 * r2].to_scale
+    @ms.each {|k, ds|
+      ds['y'].recode!{|v|
+        k == 'a' ? v * r1 : v * r2
+      }
+      ds['z'].recode!{|v|
+        k == 'a' ? v * r1 : v * r2
+      }
     }
-    ds2=@ms.union
-    assert_equal(ye,ds2['y'])
-    assert_equal(ze,ds2['z'])
-    
+    ds2 = @ms.union
+    assert_equal(ye, ds2['y'])
+    assert_equal(ze, ds2['z'])
   end
 end