statsample 1.5.0 → 2.0.0

data/test/test_factor.rb

@@ -7,26 +7,32 @@ class StatsampleFactorTestCase < Minitest::Test
   # Based on Hardle and Simar
   def setup
     @fixtures_dir = File.expand_path(File.dirname(__FILE__) + '/fixtures')
+    Daru.lazy_update = true
+  end
+
+  def teardown
+    Daru.lazy_update = false
   end
   # Based on Hurdle example
   def test_covariance_matrix
-    ds = Statsample::PlainText.read(@fixtures_dir + '/bank2.dat', %w(v1 v2 v3 v4 v5 v6))
-    ds.fields.each {|f|
-      ds[f] = ds[f].centered
+    ds = Daru::DataFrame.from_plaintext(@fixtures_dir + '/bank2.dat', [:v1,:v2,:v3,:v4,:v5,:v6])
+    ds.vectors.each {|f|
+      ds[f] = ds[f].center
     }
-    cm = ds.covariance_matrix
+    ds.update
+    cm = Statsample::Bivariate.covariance_matrix ds
     pca = Statsample::Factor::PCA.new(cm, m: 6)
     # puts pca.summary
     # puts pca.feature_matrix
-    exp_eig = [2.985, 0.931, 0.242, 0.194, 0.085, 0.035].to_numeric
-    assert_similar_vector(exp_eig, pca.eigenvalues.to_numeric, 0.1)
+    exp_eig = Daru::Vector.new([2.985, 0.931, 0.242, 0.194, 0.085, 0.035])
+    assert_similar_vector(exp_eig, Daru::Vector.new(pca.eigenvalues), 0.1)
     pcs = pca.principal_components(ds)
     k = 6
     comp_matrix = pca.component_matrix
     k.times {|i|
-      pc_id = "PC_#{i + 1}"
+      pc_id = "PC_#{i + 1}".to_sym
       k.times {|j| # variable
-        ds_id = "v#{j + 1}"
+        ds_id = "v#{j + 1}".to_sym
         r = Statsample::Bivariate.correlation(ds[ds_id], pcs[pc_id])
         assert_in_delta(r, comp_matrix[j, i])
       }
@@ -42,13 +48,13 @@ class StatsampleFactorTestCase < Minitest::Test
       samples = 20
       [3, 5, 7].each {|k|
         v = {}
-        v['x0'] = samples.times.map { ran.call }.to_numeric.centered
-        (1...k).each {|i|
-          v["x#{i}"] = samples.times.map { |ii| ran.call * 0.5 + v["x#{i - 1}"][ii] * 0.5 }.to_numeric.centered
+        v[:x0] = Daru::Vector.new(samples.times.map { ran.call }).center
+        (1...k).each { |i|
+          v["x#{i}".to_sym] = Daru::Vector.new(samples.times.map { |ii| ran.call * 0.5 + v["x#{i - 1}".to_sym][ii] * 0.5 }).center
         }
 
-        ds = v.to_dataset
-        cm = ds.covariance_matrix
+        ds = Daru::DataFrame.new(v)
+        cm = Statsample::Bivariate.covariance_matrix ds
         #      @r.assign('ds',ds)
         #      @r.eval('cm<-cor(ds);sm<-eigen(cm, sym=TRUE);v<-sm$vectors')
         #      puts "eigenvalues"
@@ -61,14 +67,14 @@ class StatsampleFactorTestCase < Minitest::Test
         cm_ruby = pca_ruby.component_matrix
         # puts cm_ruby.summary
         k.times {|i|
-          pc_id = "PC_#{i + 1}"
+          pc_id = "PC_#{i + 1}".to_sym
           assert_in_delta(pca_ruby.eigenvalues[i], pca_gsl.eigenvalues[i], 1e-10)
           # Revert gsl component values
           pc_gsl_data = (pc_gsl[pc_id][0] - pc_ruby[pc_id][0]).abs > 1e-6 ? pc_gsl[pc_id].recode(&:-@) : pc_gsl[pc_id]
           assert_similar_vector(pc_gsl_data, pc_ruby[pc_id], 1e-6, "PC for #{k} variables")
           if false
             k.times {|j| # variable
-              ds_id = "x#{j}"
+              ds_id = "x#{j}".to_sym
               r = Statsample::Bivariate.correlation(ds[ds_id], pc_ruby[pc_id])
               puts "#{pc_id}-#{ds_id}:#{r}"
             }
@@ -80,18 +86,22 @@ class StatsampleFactorTestCase < Minitest::Test
   end
 
   def test_principalcomponents
-    principalcomponents(true) if Statsample.has_gsl?
+    if Statsample.has_gsl?
+      principalcomponents(true)
+    else
+      skip "Require GSL"
+    end
     principalcomponents(false)
   end
 
   def principalcomponents(gsl)
     ran = Distribution::Normal.rng
     samples = 50
-    x1 = samples.times.map { ran.call }.to_numeric
-    x2 = samples.times.map { |i| ran.call * 0.5 + x1[i] * 0.5 }.to_numeric
-    ds = { 'x1' => x1, 'x2' => x2 }.to_dataset
+    x1 = Daru::Vector.new(samples.times.map { ran.call })
+    x2 = Daru::Vector.new(samples.times.map { |i| ran.call * 0.5 + x1[i] * 0.5 })
+    ds = Daru::DataFrame.new({ :x1 => x1, :x2 => x2 })
 
-    cm = ds.correlation_matrix
+    cm = Statsample::Bivariate.correlation_matrix ds
     r = cm[0, 1]
     pca = Statsample::Factor::PCA.new(cm, m: 2, use_gsl: gsl)
     assert_in_delta(1 + r, pca.eigenvalues[0], 1e-10)
@@ -103,14 +113,14 @@ class StatsampleFactorTestCase < Minitest::Test
     assert_equal_vector(hs * m_1, pca.eigenvectors[1])
 
     pcs = pca.principal_components(ds)
-    exp_pc_1 = ds.collect_with_index {|row, _i|
-      hs * (row['x1'] + row['x2'])
+    exp_pc_1 = ds.collect_row_with_index {|row, _i|
+      hs * (row[:x1] + row[:x2])
     }
-    exp_pc_2 = ds.collect_with_index {|row, _i|
-      gsl ? hs * (row['x2'] - row['x1']) : hs * (row['x1'] - row['x2'])
+    exp_pc_2 = ds.collect_row_with_index {|row, _i|
+      gsl ? hs * (row[:x2] - row[:x1]) : hs * (row[:x1] - row[:x2])
     }
-    assert_similar_vector(exp_pc_1, pcs['PC_1'])
-    assert_similar_vector(exp_pc_2, pcs['PC_2'])
+    assert_similar_vector(exp_pc_1, pcs[:PC_1])
+    assert_similar_vector(exp_pc_2, pcs[:PC_2])
   end
 
   def test_antiimage
@@ -121,11 +131,11 @@ class StatsampleFactorTestCase < Minitest::Test
   end
 
   def test_kmo
-    @v1 = [1, 2, 3, 4, 7, 8, 9, 10, 14, 15, 20, 50, 60, 70].to_numeric
-    @v2 = [5, 6, 11, 12, 13, 16, 17, 18, 19, 20, 30, 0, 0, 0].to_numeric
-    @v3 = [10, 3, 20, 30, 40, 50, 80, 10, 20, 30, 40, 2, 3, 4].to_numeric
+    @v1 = Daru::Vector.new([1, 2, 3, 4, 7, 8, 9, 10, 14, 15, 20, 50, 60, 70])
+    @v2 = Daru::Vector.new([5, 6, 11, 12, 13, 16, 17, 18, 19, 20, 30, 0, 0, 0])
+    @v3 = Daru::Vector.new([10, 3, 20, 30, 40, 50, 80, 10, 20, 30, 40, 2, 3, 4])
     # KMO: 0.490
-    ds = { 'v1' => @v1, 'v2' => @v2, 'v3' => @v3 }.to_dataset
+    ds = Daru::DataFrame.new({ :v1 => @v1, :v2 => @v2, :v3 => @v3 })
     cor = Statsample::Bivariate.correlation_matrix(ds)
     kmo = Statsample::Factor.kmo(cor)
     assert_in_delta(0.667, kmo, 0.001)
@@ -141,12 +151,12 @@ class StatsampleFactorTestCase < Minitest::Test
   end
   # Tested with SPSS and R
   def test_pca
-
-    a = [2.5, 0.5, 2.2, 1.9, 3.1, 2.3, 2.0, 1.0, 1.5, 1.1].to_numeric
-    b = [2.4, 0.7, 2.9, 2.2, 3.0, 2.7, 1.6, 1.1, 1.6, 0.9].to_numeric
-    a.recode! { |c| c - a.mean }
-    b.recode! { |c| c - b.mean }
-    ds = { 'a' => a, 'b' => b }.to_dataset
+    dtype = Statsample.has_gsl? ? :gsl : :array
+    a = Daru::Vector.new([2.5, 0.5, 2.2, 1.9, 3.1, 2.3, 2.0, 1.0, 1.5, 1.1], dtype: dtype)
+    b = Daru::Vector.new([2.4, 0.7, 2.9, 2.2, 3.0, 2.7, 1.6, 1.1, 1.6, 0.9], dtype: dtype)
+    a = a - a.mean
+    b = b - b.mean
+    ds = Daru::DataFrame.new({ :a => a, :b => b })
 
     cov_matrix = Statsample::Bivariate.covariance_matrix(ds)
     if Statsample.has_gsl?
@@ -160,8 +170,6 @@ class StatsampleFactorTestCase < Minitest::Test
   end
 
   def pca_set(pca, _type)
-
-
     expected_eigenvalues = [1.284, 0.0490]
     expected_eigenvalues.each_with_index{|ev, i|
       assert_in_delta(ev, pca.eigenvalues[i], 0.001)

data/test/test_factor_pa.rb

@@ -7,6 +7,11 @@ class StatsampleFactorTestCase < Minitest::Test
   # Based on Hardle and Simar
   def setup
     @fixtures_dir = File.expand_path(File.dirname(__FILE__) + '/fixtures')
+    Daru.lazy_update = true
+  end
+
+  def teardown
+    Daru.lazy_update = false
   end
 
   def test_parallelanalysis_with_data
@@ -15,26 +20,30 @@ class StatsampleFactorTestCase < Minitest::Test
       variables = 10
       iterations = 50
       rng = Distribution::Normal.rng
-      f1 = samples.times.collect { rng.call }.to_numeric
-      f2 = samples.times.collect { rng.call }.to_numeric
+      f1 = Daru::Vector.new(samples.times.collect { rng.call })
+      f2 = Daru::Vector.new(samples.times.collect { rng.call })
       vectors = {}
       variables.times do |i|
         if i < 5
-          vectors["v#{i}"] = samples.times.collect {|nv|
-            f1[nv] * 5 + f2[nv] * 2 + rng.call
-          }.to_numeric
+          vectors["v#{i}".to_sym] = Daru::Vector.new(          
+            samples.times.collect { |nv|
+              f1[nv] * 5 + f2[nv] * 2 + rng.call
+            }
+          )
         else
-          vectors["v#{i}"] = samples.times.collect {|nv|
-            f2[nv] * 5 + f1[nv] * 2 + rng.call
-          }.to_numeric
+          vectors["v#{i}".to_sym] =  Daru::Vector.new(
+            samples.times.collect { |nv|
+              f2[nv] * 5 + f1[nv] * 2 + rng.call
+            }
+          )
         end
       end
-      ds = vectors.to_dataset
+      ds = Daru::DataFrame.new(vectors)
 
       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}"
+        var = "ev_0000#{n + 1}".to_sym
         assert_in_delta(pa1.ds_eigenvalues[var].mean, pa2.ds_eigenvalues[var].mean, 0.05)
       end
     else
@@ -44,9 +53,9 @@ class StatsampleFactorTestCase < Minitest::Test
 
   def test_parallelanalysis
     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_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
 end

data/test/test_ggobi.rb

@@ -2,11 +2,11 @@ require(File.expand_path(File.dirname(__FILE__) + '/helpers_tests.rb'))
 require 'ostruct'
 class StatsampleGGobiTestCase < Minitest::Test
   def setup
-    v1 = ([10.2, 20.3, 10, 20, 30, 40, 30, 20, 30, 40] * 10).to_vector(:numeric)
-    @v2 = (%w(a b c a a a b b c d) * 10).to_vector(:object)
+    v1  = Daru::Vector.new([10.2, 20.3, 10, 20, 30, 40, 30, 20, 30, 40] * 10)
+    @v2 = Daru::Vector.new(%w(a b c a a a b b c d) * 10)
     @v2.labels = { 'a' => 'letter a', 'd' => 'letter d' }
-    v3 = ([1, 2, 3, 4, 5, 4, 3, 2, 1, 2] * 10).to_vector(:numeric)
-    @ds = { 'v1' => v1, 'v2' => @v2, 'v3' => v3 }.to_dataset
+    v3  = Daru::Vector.new([1, 2, 3, 4, 5, 4, 3, 2, 1, 2] * 10)
+    @ds = Daru::DataFrame.new({ :v1 => v1, :v2 => @v2, :v3 => v3 })
   end
 
   def test_values_definition

data/test/test_gsl.rb

@@ -1,10 +1,10 @@
 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(:numeric)
-    b = [3, 2, 3, 4, 50].to_vector(:numeric)
-    c = [6, 2, 3, 4, 3].to_vector(:numeric)
-    ds = { 'a' => a, 'b' => b, 'c' => c }.to_dataset
+    a = Daru::Vector.new([1, 2, 3, 4, 20])
+    b = Daru::Vector.new([3, 2, 3, 4, 50])
+    c = Daru::Vector.new([6, 2, 3, 4, 3])
+    ds = Daru::DataFrame.new({ :a => a, :b => b, :c => c })
     gsl = ds.to_matrix.to_gsl
     assert_equal(5, gsl.size1)
     assert_equal(3, gsl.size2)

data/test/test_histogram.rb

@@ -75,13 +75,13 @@ class StatsampleHistogramTestCase < Minitest::Test
       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_numeric
+      a = Daru::Vector.new([1.5, 1.5, 1.5, 3.5, 3.5, 3.5])
       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_numeric
+      a = Daru::Vector.new([0.5, 1.5, 1.5, 1.5, 2.5, 3.5, 3.5, 3.5, 4.5])
       h = Statsample::Histogram.alloc(5, [0, 5])
       h.increment(a)
       assert_equal(a.sd, h.estimated_standard_deviation)
@@ -100,7 +100,7 @@ class StatsampleHistogramTestCase < Minitest::Test
     end
     should 'not raise exception when all values equal' do
       assert_nothing_raised do
-        a = [5, 5, 5, 5, 5, 5].to_numeric
+        a = Daru::Vector.new([5, 5, 5, 5, 5, 5])
         h = Statsample::Graph::Histogram.new(a)
         h.to_svg
       end

data/test/test_matrix.rb

@@ -4,17 +4,17 @@ class StatsampleMatrixTestCase < Minitest::Test
   def test_to_dataset
     m = Matrix[[1, 4], [2, 5], [3, 6]]
     m.extend Statsample::NamedMatrix
-    m.fields_y = %w(x1 x2)
+    m.fields_y = [:x1, :x2]
     m.name = 'test'
     samples = 100
-    x1 = [1, 2, 3].to_numeric
-    x2 = [4, 5, 6].to_numeric
-    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)
+    x1 =Daru::Vector.new([1, 2, 3])
+    x2 =Daru::Vector.new([4, 5, 6])
+    ds = Daru::DataFrame.new({ :x1 => x1, :x2 => x2 })
+    ds.rename 'test'
+    obs = m.to_dataframe
+    assert_equal(ds[:x1], obs[:x1])
+    assert_equal(ds[:x2], obs[:x2])
+    assert_equal(ds[:x1].mean, obs[:x1].mean)
   end
 
   def test_covariate
@@ -33,10 +33,10 @@ class StatsampleMatrixTestCase < Minitest::Test
 
     assert_equal(:covariance, a._type)
 
-    a = 50.times.collect { rand }.to_numeric
-    b = 50.times.collect { rand }.to_numeric
-    c = 50.times.collect { rand }.to_numeric
-    ds = { 'a' => a, 'b' => b, 'c' => c }.to_dataset
+    a = Daru::Vector.new(50.times.collect { rand })
+    b = Daru::Vector.new(50.times.collect { rand })
+    c = Daru::Vector.new(50.times.collect { rand })
+    ds = Daru::DataFrame.new({ :a => a, :b => b, :c => c })
     corr = Statsample::Bivariate.correlation_matrix(ds)
     real = Statsample::Bivariate.covariance_matrix(ds).correlation
     corr.row_size.times do |i|

data/test/test_multiset.rb

@@ -2,122 +2,134 @@ require(File.expand_path(File.dirname(__FILE__) + '/helpers_tests.rb'))
 
 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_numeric
-    @z = [10, 11, 12, 13, 14, 15, 16, 17].to_numeric
-    @ds = { 'x' => @x, 'y' => @y, 'z' => @z }.to_dataset
-    @ms = @ds.to_multiset_by_split('x')
+    @x = Daru::Vector.new(%w(a a a a b b b b))
+    @y = Daru::Vector.new([1, 2, 3, 4, 5, 6, 7, 8])
+    @z = Daru::Vector.new([10, 11, 12, 13, 14, 15, 16, 17])
+    @ds = Daru::DataFrame.new({ :x => @x, :y => @y, :z => @z })
+    @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(%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
+    v1a = Daru::Vector.new([1, 2, 3, 4, 5])
+    v2b = Daru::Vector.new([11, 21, 31, 41, 51])
+    v3c = Daru::Vector.new([21, 23, 34, 45, 56])
+    ds1 = Daru::DataFrame.new({ :v1 => v1a, :v2 => v2b, :v3 => v3c })
+    v1b = Daru::Vector.new([15, 25, 35, 45, 55])
+    v2b = Daru::Vector.new([11, 21, 31, 41, 51])
+    v3b = Daru::Vector.new([21, 23, 34, 45, 56])
+    ds2 = Daru::DataFrame.new({ :v1 => v1b, :v2 => v2b, :v3 => v3b })
+    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 = Daru::DataFrame.new({ :v1 => v1b, :v2 => v2b })
     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)
+    ms = Statsample::Multiset.new_empty_vectors([:id, :age, :name], [:male, :female])
+    ds_male   = Daru::DataFrame.new({ 
+      :id => Daru::Vector.new([]), 
+      :age => Daru::Vector.new([]), 
+      :name => Daru::Vector.new([])
+      }, order: [:id, :age, :name])
+
+    ds_female = Daru::DataFrame.new({ 
+      :id => Daru::Vector.new([]), 
+      :age => Daru::Vector.new([]), 
+      :name => Daru::Vector.new([])
+      }, order: [:id, :age, :name])
+
+    ms2 = Statsample::Multiset.new([: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'])
+    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(:object)
-    city = %w(London Paris NY London Paris NY London Paris NY Tome).to_vector(:object)
-    age = [10, 10, 20, 30, 34, 34, 33, 35, 36, 40].to_vector(:numeric)
-    ds = { 'sex' => sex, 'city' => city, 'age' => age }.to_dataset
-    ms = ds.to_multiset_by_split('sex')
+    sex  = Daru::Vector.new(%w(m m m m m f f f f m))
+    city = Daru::Vector.new(%w(London Paris NY London Paris NY London Paris NY Tome))
+    age  = Daru::Vector.new([10, 10, 20, 30, 34, 34, 33, 35, 36, 40])
+    ds   = Daru::DataFrame.new({ :sex => sex, :city => city, :age => age })
+    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)
+    assert_equal(6, ms['m'].nrows)
+    assert_equal(4, ms['f'].nrows)
+    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(:object)
-    city = %w(London London London Paris Paris London London London Paris Paris London London London Paris Paris London London London Paris Paris).to_vector(:object)
-    hair = %w(blonde blonde black black blonde blonde black black blonde blonde black black blonde blonde black black blonde blonde black black).to_vector(:object)
-    age = [10, 10, 20, 30, 34, 34, 33, 35, 36, 40, 10, 10, 20, 30, 34, 34, 33, 35, 36, 40].to_vector(:numeric)
-    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')
+    sex = Daru::Vector.new(%w(m m m m m m m m m m f f f f f f f f f f))
+    city = Daru::Vector.new(%w(London London London Paris Paris London London London Paris Paris London London London Paris Paris London London London Paris Paris))
+    hair = Daru::Vector.new(%w(blonde blonde black black blonde blonde black black blonde blonde black black blonde blonde black black blonde blonde black black))
+    age = Daru::Vector.new([10, 10, 20, 30, 34, 34, 33, 35, 36, 40, 10, 10, 20, 30, 34, 34, 33, 35, 36, 40])
+    ds = Daru::DataFrame.new({ 
+      :sex => sex, :city => city, :hair => hair, :age => age 
+      }, order: [: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)
+    assert_equal(3, ms[%w(m London blonde)].nrows)
+    assert_equal(3, ms[%w(m London blonde)].nrows)
+    assert_equal(1, ms[%w(m Paris black)].nrows)
   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 = Daru::DataFrame.new({ :q1 => Daru::Vector.new([1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0]) })
+    ds2 = Daru::DataFrame.new({ :q1 => Daru::Vector.new([1, 1, 1, 1, 1, 1, 1, 0, 0]) })
+    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(:numeric) }.to_dataset
-    girls = { 'test' => [70, 70, 72, 72, 75, 75, 78, 78, 80, 80, 82, 82, 85, 85, 88, 88, 90, 90].to_vector(:numeric) }.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)
+    boys = Daru::DataFrame.new({ :test => Daru::Vector.new([50, 55, 60, 62, 62, 65, 67, 67, 70, 70, 73, 73, 75, 78, 78, 80, 85, 90]) })
+    girls =Daru::DataFrame.new({ :test => Daru::Vector.new( [70, 70, 72, 72, 75, 75, 78, 78, 80, 80, 82, 82, 85, 85, 88, 88, 90, 90]) })
+    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(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)
+    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
+      'a' => Daru::Vector.new(%w(a a a a)),
+      'b' => Daru::Vector.new(%w(b b b b))
     }
     ype = {
-      'a' => [1, 2, 3, 4].to_numeric,
-      'b' => [5, 6, 7, 8].to_numeric
+      'a' => Daru::Vector.new([1, 2, 3, 4]),
+      'b' => Daru::Vector.new([5, 6, 7, 8])
     }
     zpe = {
-      'a' => [10, 11, 12, 13].to_numeric,
-      'b' => [14, 15, 16, 17].to_numeric
+      'a' => Daru::Vector.new([10, 11, 12, 13]),
+      'b' => Daru::Vector.new([14, 15, 16, 17])
     }
     xp, yp, zp = {}, {}, {}
     @ms.each {|k, ds|
-      xp[k] = ds['x']
-      yp[k] = ds['y']
-      zp[k] = ds['z']
+      xp[k] = ds[:x]
+      yp[k] = ds[:y]
+      zp[k] = ds[:z]
     }
     assert_equal(xpe, xp)
     assert_equal(ype, yp)
@@ -127,38 +139,38 @@ class StatsampleMultisetTestCase < Minitest::Test
   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_numeric
+    ye = Daru::Vector.new([1 * r1, 2 * r1, 3 * r1, 4 * r1, 5 * r2, 6 * r2, 7 * r2, 8 * r2])
 
-    ze = [10 * r1, 11 * r1, 12 * r1, 13 * r1, 14 * r2, 15 * r2, 16 * r2, 17 * r2].to_numeric
+    ze = Daru::Vector.new([10 * r1, 11 * r1, 12 * r1, 13 * r1, 14 * r2, 15 * r2, 16 * r2, 17 * r2])
 
     ds2 = @ms.union {|k, ds|
-      ds['y'].recode!{|v|
+      ds[:y].recode!{|v|
         k == 'a' ? v * r1 : v * r2
       }
-      ds['z'].recode!{|v|
+      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_numeric
+    ye = Daru::Vector.new([1 * r1, 2 * r1, 3 * r1, 4 * r1, 5 * r2, 6 * r2, 7 * r2, 8 * r2])
+    ze = Daru::Vector.new([10 * r1, 11 * r1, 12 * r1, 13 * r1, 14 * r2, 15 * r2, 16 * r2, 17 * r2])
 
-    ze = [10 * r1, 11 * r1, 12 * r1, 13 * r1, 14 * r2, 15 * r2, 16 * r2, 17 * r2].to_numeric
-    @ms.each {|k, ds|
-      ds['y'].recode!{|v|
+    @ms.each do |k, ds|
+      ds[:y].recode! { |v|
         k == 'a' ? v * r1 : v * r2
       }
-      ds['z'].recode!{|v|
+      ds[:z].recode! {|v|
         k == 'a' ? v * r1 : v * r2
       }
-    }
+    end
     ds2 = @ms.union
-    assert_equal(ye, ds2['y'])
-    assert_equal(ze, ds2['z'])
+    assert_equal(ye, ds2[:y])
+    assert_equal(ze, ds2[:z])
   end
 end