statsample 1.4.3 → 1.5.0

data/lib/statsample/vector/gsl.rb

@@ -18,7 +18,7 @@ module Statsample
       end
       
       def gsl
-        @gsl||=GSL::Vector.alloc(@scale_data) if @scale_data.size>0
+        @gsl||=GSL::Vector.alloc(@numeric_data) if @numeric_data.size>0
       end
       
       alias :to_gsl :gsl
@@ -26,7 +26,7 @@ module Statsample
         if flawed?
           vector_standarized_compute_ruby(m,sd)
         else
-          gsl.collect {|x| (x.to_f - m).quo(sd)}.to_scale
+          gsl.collect {|x| (x.to_f - m).quo(sd)}.to_numeric
         end
       end
       
@@ -34,20 +34,20 @@ module Statsample
         if flawed?
           vector_centered_compute_ruby(m)
         else
-          gsl.collect {|x| (x.to_f - m)}.to_scale
+          gsl.collect {|x| (x.to_f - m)}.to_numeric
         end
       end
       def sample_with_replacement(sample=1)
-        if(@type!=:scale)
+        if(@type!=:numeric)
           sample_with_replacement_ruby(sample)
         else
           r = GSL::Rng.alloc(GSL::Rng::MT19937,rand(10000))
-          Statsample::Vector.new(r.sample(gsl, sample).to_a,:scale)
+          Statsample::Vector.new(r.sample(gsl, sample).to_a,:numeric)
         end
       end
       
       def sample_without_replacement(sample=1)
-        if(@type!=:scale)
+        if(@type!=:numeric)
           sample_without_replacement_ruby(sample)
         else
           r = GSL::Rng.alloc(GSL::Rng::MT19937,rand(10000))
@@ -55,50 +55,50 @@ module Statsample
         end
       end
       def median
-        if @type!=:scale
+        if @type!=:numeric
           median_ruby
         else
-          sorted=GSL::Vector.alloc(@scale_data.sort)
+          sorted=GSL::Vector.alloc(@numeric_data.sort)
           GSL::Stats::median_from_sorted_data(sorted)
         end
       end
       
       def sum 
-        check_type :scale
+        check_type :numeric
         gsl.nil? ? nil : gsl.sum
       end
       def mean
-        check_type :scale
+        check_type :numeric
         gsl.nil? ? nil : gsl.mean
       end				
       def variance_sample(m=nil)
-        check_type :scale
+        check_type :numeric
         m||=mean
         gsl.nil? ? nil : gsl.variance_m
       end
       
       def standard_deviation_sample(m=nil)
-        check_type :scale
+        check_type :numeric
         m||=mean
         gsl.nil? ? nil : gsl.sd(m)
       end
 
       def variance_population(m=nil) # :nodoc:
-        check_type :scale    
+        check_type :numeric    
         m||=mean
         gsl.nil? ? nil : gsl.variance_with_fixed_mean(m)
       end
       def standard_deviation_population(m=nil) # :nodoc:
-        check_type :scale
+        check_type :numeric
         m||=mean
         gsl.nil? ? nil : gsl.sd_with_fixed_mean(m)
       end
       def skew # :nodoc:
-        check_type :scale
+        check_type :numeric
         gsl.nil? ? nil : gsl.skew
       end
       def kurtosis # :nodoc:
-        check_type :scale
+        check_type :numeric
         gsl.nil? ? nil : gsl.kurtosis
       end
     end

data/lib/statsample/version.rb

@@ -1,3 +1,3 @@
 module Statsample
-  VERSION = '1.4.3'
+  VERSION = '1.5.0'
 end

data/test/test_analysis.rb

@@ -39,7 +39,7 @@ class StatsampleAnalysisTestCase < Minitest::Test
     should 'to_text returns the same as a normal ReportBuilder object' do
       rb = ReportBuilder.new(name: :test)
       section = ReportBuilder::Section.new(name: 'first')
-      a = [1, 2, 3].to_scale
+      a = [1, 2, 3].to_numeric
       section.add('first')
       section.add(a)
       rb.add(section)

data/test/test_anova_contrast.rb

@@ -2,10 +2,10 @@ require(File.expand_path(File.dirname(__FILE__) + '/helpers_tests.rb'))
 class StatsampleAnovaContrastTestCase < Minitest::Test
   context(Statsample::Anova::Contrast) do
     setup do
-      constant = [12, 13, 11, 12, 12].to_scale
-      frequent = [9, 10, 9, 13, 14].to_scale
-      infrequent = [15, 16, 17, 16, 16].to_scale
-      never = [17, 18, 12, 18, 20].to_scale
+      constant = [12, 13, 11, 12, 12].to_numeric
+      frequent = [9, 10, 9, 13, 14].to_numeric
+      infrequent = [15, 16, 17, 16, 16].to_numeric
+      never = [17, 18, 12, 18, 20].to_numeric
       @vectors = [constant, frequent, infrequent, never]
       @c = Statsample::Anova::Contrast.new(vectors: @vectors)
     end

data/test/test_anovatwowaywithdataset.rb

@@ -4,7 +4,7 @@ require(File.expand_path(File.dirname(__FILE__) + '/helpers_tests.rb'))
 class StatsampleAnovaTwoWayWithVectorsTestCase < Minitest::Test
   context(Statsample::Anova::TwoWayWithVectors) do
     setup do
-      @pa = [5, 4, 3, 4, 2, 18, 19, 14, 12, 15, 6, 7, 5, 8, 4, 6, 9, 5, 9, 3].to_scale
+      @pa = [5, 4, 3, 4, 2, 18, 19, 14, 12, 15, 6, 7, 5, 8, 4, 6, 9, 5, 9, 3].to_numeric
       @pa.name = 'Passive Avoidance'
       @a = [0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1].to_vector
       @a.labels = { 0 => '0%', 1 => '35%' }

data/test/test_anovawithvectors.rb

@@ -3,9 +3,9 @@ class StatsampleAnovaOneWayWithVectorsTestCase < Minitest::Test
   context(Statsample::Anova::OneWayWithVectors) do
     context('when initializing') do
       setup do
-        @v1 = 10.times.map { rand(100) }.to_scale
-        @v2 = 10.times.map { rand(100) }.to_scale
-        @v3 = 10.times.map { rand(100) }.to_scale
+        @v1 = 10.times.map { rand(100) }.to_numeric
+        @v2 = 10.times.map { rand(100) }.to_numeric
+        @v3 = 10.times.map { rand(100) }.to_numeric
       end
       should 'be the same using [] or args*' do
         a1 = Statsample::Anova::OneWayWithVectors.new(@v1, @v2, @v3)
@@ -28,9 +28,9 @@ class StatsampleAnovaOneWayWithVectorsTestCase < Minitest::Test
       end
     end
     setup do
-      @v1 = [3, 3, 2, 3, 6].to_vector(:scale)
-      @v2 = [7, 6, 5, 6, 7].to_vector(:scale)
-      @v3 = [9, 8, 9, 7, 8].to_vector(:scale)
+      @v1 = [3, 3, 2, 3, 6].to_vector(:numeric)
+      @v2 = [7, 6, 5, 6, 7].to_vector(:numeric)
+      @v3 = [9, 8, 9, 7, 8].to_vector(:numeric)
       @name = 'Anova testing'
       @anova = Statsample::Anova::OneWayWithVectors.new(@v1, @v2, @v3, name: @name)
     end

data/test/test_awesome_print_bug.rb

@@ -5,7 +5,7 @@ class StatsampleAwesomePrintBug < Minitest::Test
       require 'awesome_print'
     end
     should 'should be flawless' do
-      a = [1, 2, 3].to_scale
+      a = [1, 2, 3].to_numeric
 
       assert(a != [1, 2, 3])
       assert_nothing_raised do

data/test/test_bartlettsphericity.rb

@@ -4,9 +4,9 @@ class StatsampleBartlettSphericityTestCase < Minitest::Test
   include Statsample::Test
   context Statsample::Test::BartlettSphericity do
     setup do
-      @v1 = [1, 2, 3, 4, 7, 8, 9, 10, 14, 15, 20, 50, 60, 70].to_scale
-      @v2 = [5, 6, 11, 12, 13, 16, 17, 18, 19, 20, 30, 0, 0, 0].to_scale
-      @v3 = [10, 3, 20, 30, 40, 50, 80, 10, 20, 30, 40, 2, 3, 4].to_scale
+      @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
       # KMO: 0.490
       ds = { 'v1' => @v1, 'v2' => @v2, 'v3' => @v3 }.to_dataset
       cor = Statsample::Bivariate.correlation_matrix(ds)

data/test/test_bivariate.rb

@@ -1,38 +1,38 @@
 require(File.expand_path(File.dirname(__FILE__) + '/helpers_tests.rb'))
 class StatsampleBivariateTestCase < Minitest::Test
   should 'method sum of squares should be correct' do
-    v1 = [1, 2, 3, 4, 5, 6].to_vector(:scale)
-    v2 = [6, 2, 4, 10, 12, 8].to_vector(:scale)
+    v1 = [1, 2, 3, 4, 5, 6].to_vector(:numeric)
+    v2 = [6, 2, 4, 10, 12, 8].to_vector(:numeric)
     assert_equal(23.0, Statsample::Bivariate.sum_of_squares(v1, v2))
   end
   should_with_gsl 'return same covariance with ruby and gls implementation' do
-    v1 = 20.times.collect { |_a| rand }.to_scale
-    v2 = 20.times.collect { |_a| rand }.to_scale
+    v1 = 20.times.collect { |_a| rand }.to_numeric
+    v2 = 20.times.collect { |_a| rand }.to_numeric
     assert_in_delta(Statsample::Bivariate.covariance(v1, v2), Statsample::Bivariate.covariance_slow(v1, v2), 0.001)
   end
 
   should_with_gsl 'return same correlation with ruby and gls implementation' do
-    v1 = 20.times.collect { |_a| rand }.to_scale
-    v2 = 20.times.collect { |_a| rand }.to_scale
+    v1 = 20.times.collect { |_a| rand }.to_numeric
+    v2 = 20.times.collect { |_a| rand }.to_numeric
 
     assert_in_delta(GSL::Stats.correlation(v1.gsl, v2.gsl), Statsample::Bivariate.pearson_slow(v1, v2), 1e-10)
   end
   should 'return correct pearson correlation' do
-    v1 = [6, 5, 4, 7, 8, 4, 3, 2].to_vector(:scale)
-    v2 = [2, 3, 7, 8, 6, 4, 3, 2].to_vector(:scale)
+    v1 = [6, 5, 4, 7, 8, 4, 3, 2].to_vector(:numeric)
+    v2 = [2, 3, 7, 8, 6, 4, 3, 2].to_vector(:numeric)
     assert_in_delta(0.525, Statsample::Bivariate.pearson(v1, v2), 0.001)
     assert_in_delta(0.525, Statsample::Bivariate.pearson_slow(v1, v2), 0.001)
 
-    v3 = [6, 2,  1000, 1000, 5, 4, 7, 8, 4, 3, 2, nil].to_vector(:scale)
-    v4 = [2, nil, nil, nil,  3, 7, 8, 6, 4, 3, 2, 500].to_vector(:scale)
+    v3 = [6, 2,  1000, 1000, 5, 4, 7, 8, 4, 3, 2, nil].to_vector(:numeric)
+    v4 = [2, nil, nil, nil,  3, 7, 8, 6, 4, 3, 2, 500].to_vector(:numeric)
     assert_in_delta(0.525, Statsample::Bivariate.pearson(v3, v4), 0.001)
     # Test ruby method
     v3a, v4a = Statsample.only_valid v3, v4
     assert_in_delta(0.525, Statsample::Bivariate.pearson_slow(v3a, v4a), 0.001)
   end
   should 'return correct values for t_pearson and prop_pearson' do
-    v1 = [6, 5, 4, 7, 8, 4, 3, 2].to_vector(:scale)
-    v2 = [2, 3, 7, 8, 6, 4, 3, 2].to_vector(:scale)
+    v1 = [6, 5, 4, 7, 8, 4, 3, 2].to_vector(:numeric)
+    v2 = [2, 3, 7, 8, 6, 4, 3, 2].to_vector(:numeric)
     r = Statsample::Bivariate::Pearson.new(v1, v2)
     assert_in_delta(0.525, r.r, 0.001)
     assert_in_delta(Statsample::Bivariate.t_pearson(v1, v2), r.t, 0.001)
@@ -40,10 +40,10 @@ class StatsampleBivariateTestCase < Minitest::Test
     assert(r.summary.size > 0)
   end
   should 'return correct correlation_matrix with nils values' do
-    v1 = [6, 5, 4, 7, 8, 4, 3, 2].to_vector(:scale)
-    v2 = [2, 3, 7, 8, 6, 4, 3, 2].to_vector(:scale)
-    v3 = [6, 2,  1000, 1000, 5, 4, 7, 8].to_vector(:scale)
-    v4 = [2, nil, nil, nil,  3, 7, 8, 6].to_vector(:scale)
+    v1 = [6, 5, 4, 7, 8, 4, 3, 2].to_vector(:numeric)
+    v2 = [2, 3, 7, 8, 6, 4, 3, 2].to_vector(:numeric)
+    v3 = [6, 2,  1000, 1000, 5, 4, 7, 8].to_vector(:numeric)
+    v4 = [2, nil, nil, nil,  3, 7, 8, 6].to_vector(:numeric)
     ds = { 'v1' => v1, 'v2' => v2, 'v3' => v3, 'v4' => v4 }.to_dataset
     c = proc { |n1, n2| Statsample::Bivariate.pearson(n1, n2) }
     expected = Matrix[[c.call(v1, v1), c.call(v1, v2), c.call(v1, v3), c.call(v1, v4)], [c.call(v2, v1), c.call(v2, v2), c.call(v2, v3), c.call(v2, v4)], [c.call(v3, v1), c.call(v3, v2), c.call(v3, v3), c.call(v3, v4)],
@@ -61,11 +61,11 @@ class StatsampleBivariateTestCase < Minitest::Test
   end
   should_with_gsl 'return same values for optimized and pairwise covariance matrix' do
     cases = 100
-    v1 = Statsample::Vector.new_scale(cases) { rand }
-    v2 = Statsample::Vector.new_scale(cases) { rand }
-    v3 = Statsample::Vector.new_scale(cases) { rand }
-    v4 = Statsample::Vector.new_scale(cases) { rand }
-    v5 = Statsample::Vector.new_scale(cases) { rand }
+    v1 = Statsample::Vector.new_numeric(cases) { rand }
+    v2 = Statsample::Vector.new_numeric(cases) { rand }
+    v3 = Statsample::Vector.new_numeric(cases) { rand }
+    v4 = Statsample::Vector.new_numeric(cases) { rand }
+    v5 = Statsample::Vector.new_numeric(cases) { rand }
 
     ds = { 'v1' => v1, 'v2' => v2, 'v3' => v3, 'v4' => v4, 'v5' => v5 }.to_dataset
 
@@ -76,11 +76,11 @@ class StatsampleBivariateTestCase < Minitest::Test
   end
   should_with_gsl 'return same values for optimized and pairwise correlation matrix' do
     cases = 100
-    v1 = Statsample::Vector.new_scale(cases) { rand }
-    v2 = Statsample::Vector.new_scale(cases) { rand }
-    v3 = Statsample::Vector.new_scale(cases) { rand }
-    v4 = Statsample::Vector.new_scale(cases) { rand }
-    v5 = Statsample::Vector.new_scale(cases) { rand }
+    v1 = Statsample::Vector.new_numeric(cases) { rand }
+    v2 = Statsample::Vector.new_numeric(cases) { rand }
+    v3 = Statsample::Vector.new_numeric(cases) { rand }
+    v4 = Statsample::Vector.new_numeric(cases) { rand }
+    v5 = Statsample::Vector.new_numeric(cases) { rand }
 
     ds = { 'v1' => v1, 'v2' => v2, 'v3' => v3, 'v4' => v4, 'v5' => v5 }.to_dataset
 
@@ -90,10 +90,10 @@ class StatsampleBivariateTestCase < Minitest::Test
     assert_equal_matrix(cor_opt, cor_pw, 1e-15)
   end
   should 'return correct correlation_matrix without nils values' do
-    v1 = [6, 5, 4, 7, 8, 4, 3, 2].to_vector(:scale)
-    v2 = [2, 3, 7, 8, 6, 4, 3, 2].to_vector(:scale)
-    v3 = [6, 2,  1000, 1000, 5, 4, 7, 8].to_vector(:scale)
-    v4 = [2, 4, 6, 7,  3, 7, 8, 6].to_vector(:scale)
+    v1 = [6, 5, 4, 7, 8, 4, 3, 2].to_vector(:numeric)
+    v2 = [2, 3, 7, 8, 6, 4, 3, 2].to_vector(:numeric)
+    v3 = [6, 2,  1000, 1000, 5, 4, 7, 8].to_vector(:numeric)
+    v4 = [2, 4, 6, 7,  3, 7, 8, 6].to_vector(:numeric)
     ds = { 'v1' => v1, 'v2' => v2, 'v3' => v3, 'v4' => v4 }.to_dataset
     c = proc { |n1, n2| Statsample::Bivariate.pearson(n1, n2) }
     expected = Matrix[[c.call(v1, v1), c.call(v1, v2), c.call(v1, v3), c.call(v1, v4)], [c.call(v2, v1), c.call(v2, v2), c.call(v2, v3), c.call(v2, v4)], [c.call(v3, v1), c.call(v3, v2), c.call(v3, v3), c.call(v3, v4)],
@@ -129,25 +129,25 @@ class StatsampleBivariateTestCase < Minitest::Test
   end
 
   should "return correct value for Spearman's rho" do
-    v1 = [86, 97, 99, 100, 101, 103, 106, 110, 112, 113].to_vector(:scale)
-    v2 = [0, 20, 28, 27, 50, 29, 7, 17, 6, 12].to_vector(:scale)
+    v1 = [86, 97, 99, 100, 101, 103, 106, 110, 112, 113].to_vector(:numeric)
+    v2 = [0, 20, 28, 27, 50, 29, 7, 17, 6, 12].to_vector(:numeric)
     assert_in_delta(-0.175758, Statsample::Bivariate.spearman(v1, v2), 0.0001)
   end
   should 'return correct value for point_biserial correlation' do
-    c = [1, 3, 5, 6, 7, 100, 200, 300, 400, 300].to_vector(:scale)
-    d = [1, 1, 1, 1, 1, 0, 0, 0, 0, 0].to_vector(:scale)
+    c = [1, 3, 5, 6, 7, 100, 200, 300, 400, 300].to_vector(:numeric)
+    d = [1, 1, 1, 1, 1, 0, 0, 0, 0, 0].to_vector(:numeric)
     assert_raises TypeError do
       Statsample::Bivariate.point_biserial(c, d)
     end
     assert_in_delta(Statsample::Bivariate.point_biserial(d, c), Statsample::Bivariate.pearson(d, c), 0.0001)
   end
   should 'return correct value for tau_a and tau_b' do
-    v1 = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11].to_vector(:ordinal)
-    v2 = [1, 3, 4, 5, 7, 8, 2, 9, 10, 6, 11].to_vector(:ordinal)
+    v1 = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11].to_vector(:numeric)
+    v2 = [1, 3, 4, 5, 7, 8, 2, 9, 10, 6, 11].to_vector(:numeric)
     assert_in_delta(0.6727, Statsample::Bivariate.tau_a(v1, v2), 0.001)
     assert_in_delta(0.6727, Statsample::Bivariate.tau_b((Statsample::Crosstab.new(v1, v2).to_matrix)), 0.001)
-    v1 = [12, 14, 14, 17, 19, 19, 19, 19, 19, 20, 21, 21, 21, 21, 21, 22, 23, 24, 24, 24, 26, 26, 27].to_vector(:ordinal)
-    v2 = [11, 4, 4, 2, 0, 0, 0, 0, 0, 0, 4, 0, 4, 0, 0, 0, 0, 4, 0, 0, 0, 0, 0].to_vector(:ordinal)
+    v1 = [12, 14, 14, 17, 19, 19, 19, 19, 19, 20, 21, 21, 21, 21, 21, 22, 23, 24, 24, 24, 26, 26, 27].to_vector(:numeric)
+    v2 = [11, 4, 4, 2, 0, 0, 0, 0, 0, 0, 4, 0, 4, 0, 0, 0, 0, 4, 0, 0, 0, 0, 0].to_vector(:numeric)
     assert_in_delta(-0.376201540231705, Statsample::Bivariate.tau_b(Statsample::Crosstab.new(v1, v2).to_matrix), 0.001)
   end
   should 'return correct value for gamma correlation' do

data/test/test_crosstab.rb

@@ -58,8 +58,8 @@ class StatsampleCrosstabTestCase < Minitest::Test
   end
 
   def test_crosstab_with_scale
-    v1 = %w(1 1 1 1 1 0 0 0 0 0).to_scale
-    v2 = %w(0 0 0 0 0 1 1 1 1 1).to_scale
+    v1 = %w(1 1 1 1 1 0 0 0 0 0).to_numeric
+    v2 = %w(0 0 0 0 0 1 1 1 1 1).to_numeric
     ct = Statsample::Crosstab.new(v1, v2)
     assert_equal(Matrix[[0, 5], [5, 0]], ct.to_matrix)
     assert_nothing_raised { ct.summary }

data/test/test_csv.rb

@@ -8,11 +8,11 @@ class StatsampleCSVTestCase < Minitest::Test
   def test_read
     header = %w(id name age city a1)
     data = {
-      'id' => [1, 2, 3, 4, 5, 6].to_vector(:scale),
-      'name' => %w(Alex Claude Peter Franz George Fernand).to_vector(:nominal),
-      'age' => [20, 23, 25, 27, 5.5, nil].to_vector(:scale),
-      'city' => ['New York', 'London', 'London', 'Paris', 'Tome', nil].to_vector(:nominal),
-      'a1' => ['a,b', 'b,c', 'a', nil, 'a,b,c', nil].to_vector(:nominal)
+      'id' => [1, 2, 3, 4, 5, 6].to_vector(:numeric),
+      'name' => %w(Alex Claude Peter Franz George Fernand).to_vector(:object),
+      'age' => [20, 23, 25, 27, 5.5, nil].to_vector(:numeric),
+      'city' => ['New York', 'London', 'London', 'Paris', 'Tome', nil].to_vector(:object),
+      'a1' => ['a,b', 'b,c', 'a', nil, 'a,b,c', nil].to_vector(:object)
     }
 
     ds_exp = Statsample::Dataset.new(data, header)
@@ -34,7 +34,7 @@ class StatsampleCSVTestCase < Minitest::Test
   def test_repeated
     ds = Statsample::CSV.read('test/fixtures/repeated_fields.csv')
     assert_equal(%w(id name_1 age_1 city a1 name_2 age_2), ds.fields)
-    age = [3, 4, 5, 6, nil, 8].to_vector(:scale)
+    age = [3, 4, 5, 6, nil, 8].to_vector(:numeric)
     assert_equal(age, ds['age_2'])
   end
 

data/test/test_dataset.rb

@@ -58,9 +58,9 @@ class StatsampleDatasetTestCase < Minitest::Test
   end
 
   def test_merge
-    a = [1, 2, 3].to_scale
+    a = [1, 2, 3].to_numeric
     b = [3, 4, 5].to_vector
-    c = [4, 5, 6].to_scale
+    c = [4, 5, 6].to_numeric
     d = [7, 8, 9].to_vector
     e = [10, 20, 30].to_vector
     ds1 = { 'a' => a, 'b' => b }.to_dataset
@@ -117,51 +117,51 @@ class StatsampleDatasetTestCase < Minitest::Test
   end
 
   def test_vector_by_calculation
-    a1 = [1, 2, 3, 4, 5, 6, 7].to_vector(:scale)
-    a2 = [10, 20, 30, 40, 50, 60, 70].to_vector(:scale)
-    a3 = [100, 200, 300, 400, 500, 600, 700].to_vector(:scale)
+    a1 = [1, 2, 3, 4, 5, 6, 7].to_vector(:numeric)
+    a2 = [10, 20, 30, 40, 50, 60, 70].to_vector(:numeric)
+    a3 = [100, 200, 300, 400, 500, 600, 700].to_vector(:numeric)
     ds = { 'a1' => a1, 'a2' => a2, 'a3' => a3 }.to_dataset
     total = ds.vector_by_calculation {|row|
       row['a1'] + row['a2'] + row['a3']
     }
-    expected = [111, 222, 333, 444, 555, 666, 777].to_vector(:scale)
+    expected = [111, 222, 333, 444, 555, 666, 777].to_vector(:numeric)
     assert_equal(expected, total)
   end
 
   def test_vector_sum
-    a1 = [1, 2, 3, 4, 5, nil].to_vector(:scale)
-    a2 = [10, 10, 20, 20, 20, 30].to_vector(:scale)
-    b1 = [nil, 1, 1, 1, 1, 2].to_vector(:scale)
-    b2 = [2, 2, 2, nil, 2, 3].to_vector(:scale)
+    a1 = [1, 2, 3, 4, 5, nil].to_vector(:numeric)
+    a2 = [10, 10, 20, 20, 20, 30].to_vector(:numeric)
+    b1 = [nil, 1, 1, 1, 1, 2].to_vector(:numeric)
+    b2 = [2, 2, 2, nil, 2, 3].to_vector(:numeric)
     ds = { 'a1' => a1, 'a2' => a2, 'b1' => b1, 'b2' => b2 }.to_dataset
     total = ds.vector_sum
     a = ds.vector_sum(%w(a1 a2))
     b = ds.vector_sum(%w(b1 b2))
-    expected_a = [11, 12, 23, 24, 25, nil].to_vector(:scale)
-    expected_b = [nil, 3, 3, nil, 3, 5].to_vector(:scale)
-    expected_total = [nil, 15, 26, nil, 28, nil].to_vector(:scale)
+    expected_a = [11, 12, 23, 24, 25, nil].to_vector(:numeric)
+    expected_b = [nil, 3, 3, nil, 3, 5].to_vector(:numeric)
+    expected_total = [nil, 15, 26, nil, 28, nil].to_vector(:numeric)
     assert_equal(expected_a, a)
     assert_equal(expected_b, b)
     assert_equal(expected_total, total)
   end
 
   def test_vector_missing_values
-    a1 = [1, nil, 3, 4, 5, nil].to_vector(:scale)
-    a2 = [10, nil, 20, 20, 20, 30].to_vector(:scale)
-    b1 = [nil, nil, 1, 1, 1, 2].to_vector(:scale)
-    b2 = [2, 2, 2, nil, 2, 3].to_vector(:scale)
-    c = [nil, 2, 4, 2, 2, 2].to_vector(:scale)
+    a1 = [1, nil, 3, 4, 5, nil].to_vector(:numeric)
+    a2 = [10, nil, 20, 20, 20, 30].to_vector(:numeric)
+    b1 = [nil, nil, 1, 1, 1, 2].to_vector(:numeric)
+    b2 = [2, 2, 2, nil, 2, 3].to_vector(:numeric)
+    c = [nil, 2, 4, 2, 2, 2].to_vector(:numeric)
     ds = { 'a1' => a1, 'a2' => a2, 'b1' => b1, 'b2' => b2, 'c' => c }.to_dataset
-    mva = [2, 3, 0, 1, 0, 1].to_vector(:scale)
+    mva = [2, 3, 0, 1, 0, 1].to_vector(:numeric)
     assert_equal(mva, ds.vector_missing_values)
   end
 
   def test_has_missing_values
-    a1 = [1, nil, 3, 4, 5, nil].to_vector(:scale)
-    a2 = [10, nil, 20, 20, 20, 30].to_vector(:scale)
-    b1 = [nil, nil, 1, 1, 1, 2].to_vector(:scale)
-    b2 = [2, 2, 2, nil, 2, 3].to_vector(:scale)
-    c = [nil, 2, 4, 2, 2, 2].to_vector(:scale)
+    a1 = [1, nil, 3, 4, 5, nil].to_vector(:numeric)
+    a2 = [10, nil, 20, 20, 20, 30].to_vector(:numeric)
+    b1 = [nil, nil, 1, 1, 1, 2].to_vector(:numeric)
+    b2 = [2, 2, 2, nil, 2, 3].to_vector(:numeric)
+    c = [nil, 2, 4, 2, 2, 2].to_vector(:numeric)
     ds = { 'a1' => a1, 'a2' => a2, 'b1' => b1, 'b2' => b2, 'c' => c }.to_dataset
     assert(ds.has_missing_data?)
     clean = ds.dup_only_valid
@@ -169,31 +169,31 @@ class StatsampleDatasetTestCase < Minitest::Test
   end
 
   def test_vector_count_characters
-    a1 = [1, 'abcde', 3, 4, 5, nil].to_vector(:scale)
-    a2 = [10, 20.3, 20, 20, 20, 30].to_vector(:scale)
-    b1 = [nil, '343434', 1, 1, 1, 2].to_vector(:scale)
-    b2 = [2, 2, 2, nil, 2, 3].to_vector(:scale)
-    c = [nil, 2, 'This is a nice example', 2, 2, 2].to_vector(:scale)
+    a1 = [1, 'abcde', 3, 4, 5, nil].to_vector(:numeric)
+    a2 = [10, 20.3, 20, 20, 20, 30].to_vector(:numeric)
+    b1 = [nil, '343434', 1, 1, 1, 2].to_vector(:numeric)
+    b2 = [2, 2, 2, nil, 2, 3].to_vector(:numeric)
+    c = [nil, 2, 'This is a nice example', 2, 2, 2].to_vector(:numeric)
     ds = { 'a1' => a1, 'a2' => a2, 'b1' => b1, 'b2' => b2, 'c' => c }.to_dataset
-    exp = [4, 17, 27, 5, 6, 5].to_vector(:scale)
+    exp = [4, 17, 27, 5, 6, 5].to_vector(:numeric)
     assert_equal(exp, ds.vector_count_characters)
   end
 
   def test_vector_mean
-    a1 = [1, 2, 3, 4, 5, nil].to_vector(:scale)
-    a2 = [10, 10, 20, 20, 20, 30].to_vector(:scale)
-    b1 = [nil, 1, 1, 1, 1, 2].to_vector(:scale)
-    b2 = [2, 2, 2, nil, 2, 3].to_vector(:scale)
-    c = [nil, 2, 4, 2, 2, 2].to_vector(:scale)
+    a1 = [1, 2, 3, 4, 5, nil].to_vector(:numeric)
+    a2 = [10, 10, 20, 20, 20, 30].to_vector(:numeric)
+    b1 = [nil, 1, 1, 1, 1, 2].to_vector(:numeric)
+    b2 = [2, 2, 2, nil, 2, 3].to_vector(:numeric)
+    c = [nil, 2, 4, 2, 2, 2].to_vector(:numeric)
     ds = { 'a1' => a1, 'a2' => a2, 'b1' => b1, 'b2' => b2, 'c' => c }.to_dataset
     total = ds.vector_mean
     a = ds.vector_mean(%w(a1 a2), 1)
     b = ds.vector_mean(%w(b1 b2), 1)
     c = ds.vector_mean(%w(b1 b2 c), 1)
-    expected_a = [5.5, 6, 11.5, 12, 12.5, 30].to_vector(:scale)
-    expected_b = [2, 1.5, 1.5, 1, 1.5, 2.5].to_vector(:scale)
-    expected_c = [nil, 5.0 / 3, 7.0 / 3, 1.5, 5.0 / 3, 7.0 / 3].to_vector(:scale)
-    expected_total = [nil, 3.4, 6, nil, 6.0, nil].to_vector(:scale)
+    expected_a = [5.5, 6, 11.5, 12, 12.5, 30].to_vector(:numeric)
+    expected_b = [2, 1.5, 1.5, 1, 1.5, 2.5].to_vector(:numeric)
+    expected_c = [nil, 5.0 / 3, 7.0 / 3, 1.5, 5.0 / 3, 7.0 / 3].to_vector(:numeric)
+    expected_total = [nil, 3.4, 6, nil, 6.0, nil].to_vector(:numeric)
     assert_equal(expected_a, a)
     assert_equal(expected_b, b)
     assert_equal(expected_c, c)
@@ -210,9 +210,9 @@ class StatsampleDatasetTestCase < Minitest::Test
   end
 
   def test_recode
-    @ds['age'].type = :scale
+    @ds['age'].type = :numeric
     @ds.recode!('age') { |c| c['id'] * 2 }
-    expected = [2, 4, 6, 8, 10].to_vector(:scale)
+    expected = [2, 4, 6, 8, 10].to_vector(:numeric)
     assert_equal(expected, @ds['age'])
   end
 
@@ -231,8 +231,8 @@ class StatsampleDatasetTestCase < Minitest::Test
   end
 
   def test_change_type
-    @ds.col('age').type = :scale
-    assert_equal(:scale, @ds.col('age').type)
+    @ds.col('age').type = :numeric
+    assert_equal(:numeric, @ds.col('age').type)
   end
 
   def test_split_by_separator_recode
@@ -255,13 +255,13 @@ class StatsampleDatasetTestCase < Minitest::Test
   end
 
   def test_percentiles
-    v1 = (1..100).to_a.to_scale
+    v1 = (1..100).to_a.to_numeric
     assert_equal(50.5, v1.median)
     assert_equal(25.5, v1.percentil(25))
-    v2 = (1..99).to_a.to_scale
+    v2 = (1..99).to_a.to_numeric
     assert_equal(50, v2.median)
     assert_equal(25, v2.percentil(25))
-    v3 = (1..50).to_a.to_scale
+    v3 = (1..50).to_a.to_numeric
     assert_equal(25.5, v3.median)
     assert_equal(13, v3.percentil(25))
   end
@@ -336,7 +336,7 @@ class StatsampleDatasetTestCase < Minitest::Test
 
     assert_equal(ds1.fields, ds2.fields)
     assert_not_same(ds1.fields, ds2.fields)
-    ds1['v1'].type = :scale
+    ds1['v1'].type = :numeric
     # dup partial
     ds3 = ds1.dup('v1')
     ds_exp = Statsample::Dataset.new({ 'v1' => v1 }, %w(v1))
@@ -355,7 +355,7 @@ class StatsampleDatasetTestCase < Minitest::Test
     assert_not_equal(ds1['v1'], ds3['v1'])
     assert_equal([], ds3['v1'].data)
     assert_equal([], ds3['v2'].data)
-    assert_equal(:scale, ds3['v1'].type)
+    assert_equal(:numeric, ds3['v1'].type)
     assert_equal(ds1.fields, ds2.fields)
     assert_not_same(ds1.fields, ds2.fields)
   end
@@ -368,9 +368,9 @@ class StatsampleDatasetTestCase < Minitest::Test
   end
 
   def test_each_array_with_nils
-    v1 = [1, -99, 3, 4, 'na'].to_vector(:scale, missing_values: [-99, 'na'])
-    v2 = [5, 6, -99, 8, 20].to_vector(:scale, missing_values: [-99])
-    v3 = [9, 10, 11, 12, 20].to_vector(:scale, missing_values: [-99])
+    v1 = [1, -99, 3, 4, 'na'].to_vector(:numeric, missing_values: [-99, 'na'])
+    v2 = [5, 6, -99, 8, 20].to_vector(:numeric, missing_values: [-99])
+    v3 = [9, 10, 11, 12, 20].to_vector(:numeric, missing_values: [-99])
     ds1 = Statsample::Dataset.new('v1' => v1, 'v2' => v2, 'v3' => v3)
     ds2 = ds1.dup_empty
     ds1.each_array_with_nils {|row|
@@ -382,40 +382,40 @@ class StatsampleDatasetTestCase < Minitest::Test
   end
 
   def test_dup_only_valid
-    v1 = [1, nil, 3, 4].to_vector(:scale)
-    v2 = [5, 6, nil, 8].to_vector(:scale)
-    v3 = [9, 10, 11, 12].to_vector(:scale)
+    v1 = [1, nil, 3, 4].to_vector(:numeric)
+    v2 = [5, 6, nil, 8].to_vector(:numeric)
+    v3 = [9, 10, 11, 12].to_vector(:numeric)
     ds1 = Statsample::Dataset.new('v1' => v1, 'v2' => v2, 'v3' => v3)
     ds2 = ds1.dup_only_valid
-    expected = Statsample::Dataset.new('v1' => [1, 4].to_vector(:scale), 'v2' => [5, 8].to_vector(:scale), 'v3' => [9, 12].to_vector(:scale))
+    expected = Statsample::Dataset.new('v1' => [1, 4].to_vector(:numeric), 'v2' => [5, 8].to_vector(:numeric), 'v3' => [9, 12].to_vector(:numeric))
     assert_equal(expected, ds2)
     assert_equal(expected.vectors.values, Statsample.only_valid(v1, v2, v3))
-    expected_partial = Statsample::Dataset.new('v1' => [1, 3, 4].to_vector(:scale), 'v3' => [9, 11, 12].to_vector(:scale))
+    expected_partial = Statsample::Dataset.new('v1' => [1, 3, 4].to_vector(:numeric), 'v3' => [9, 11, 12].to_vector(:numeric))
     assert_equal(expected_partial, ds1.dup_only_valid(%w(v1 v3)))
   end
 
   def test_filter
-    @ds['age'].type = :scale
+    @ds['age'].type = :numeric
     filtered = @ds.filter { |c| c['id'] == 2 or c['id'] == 4 }
-    expected = Statsample::Dataset.new({ 'id' => Statsample::Vector.new([2, 4]), 'name' => Statsample::Vector.new(%w(Claude Franz)), 'age' => Statsample::Vector.new([23, 27], :scale),
+    expected = Statsample::Dataset.new({ 'id' => Statsample::Vector.new([2, 4]), 'name' => Statsample::Vector.new(%w(Claude Franz)), 'age' => Statsample::Vector.new([23, 27], :numeric),
                                          'city' => Statsample::Vector.new(%w(London Paris)),
                                          'a1' => Statsample::Vector.new(['b,c', nil]) }, %w(id name age city a1))
     assert_equal(expected, filtered)
   end
 
   def test_filter_field
-    @ds['age'].type = :scale
+    @ds['age'].type = :numeric
     filtered = @ds.filter_field('id') { |c| c['id'] == 2 or c['id'] == 4 }
     expected = [2, 4].to_vector
     assert_equal(expected, filtered)
   end
 
   def test_verify
-    name = %w(r1 r2 r3 r4).to_vector(:nominal)
-    v1 = [1, 2, 3, 4].to_vector(:scale)
-    v2 = [4, 3, 2, 1].to_vector(:scale)
-    v3 = [10, 20, 30, 40].to_vector(:scale)
-    v4 = %w(a b a b).to_vector(:nominal)
+    name = %w(r1 r2 r3 r4).to_vector(:object)
+    v1 = [1, 2, 3, 4].to_vector(:numeric)
+    v2 = [4, 3, 2, 1].to_vector(:numeric)
+    v3 = [10, 20, 30, 40].to_vector(:numeric)
+    v4 = %w(a b a b).to_vector(:object)
     ds = { 'v1' => v1, 'v2' => v2, 'v3' => v3, 'v4' => v4, 'id' => name }.to_dataset
     ds.fields = %w(v1 v2 v3 v4 id)
     # Correct
@@ -432,14 +432,14 @@ class StatsampleDatasetTestCase < Minitest::Test
   end
 
   def test_compute_operation
-    v1 = [1, 2, 3, 4].to_vector(:scale)
-    v2 = [4, 3, 2, 1].to_vector(:scale)
-    v3 = [10, 20, 30, 40].to_vector(:scale)
-    vscale = [1.quo(2), 1, 3.quo(2), 2].to_vector(:scale)
-    vsum = [1 + 4 + 10.0, 2 + 3 + 20.0, 3 + 2 + 30.0, 4 + 1 + 40.0].to_vector(:scale)
-    vmult = [1 * 4, 2 * 3, 3 * 2, 4 * 1].to_vector(:scale)
+    v1 = [1, 2, 3, 4].to_vector(:numeric)
+    v2 = [4, 3, 2, 1].to_vector(:numeric)
+    v3 = [10, 20, 30, 40].to_vector(:numeric)
+    vnumeric = [1.quo(2), 1, 3.quo(2), 2].to_vector(:numeric)
+    vsum = [1 + 4 + 10.0, 2 + 3 + 20.0, 3 + 2 + 30.0, 4 + 1 + 40.0].to_vector(:numeric)
+    vmult = [1 * 4, 2 * 3, 3 * 2, 4 * 1].to_vector(:numeric)
     ds = { 'v1' => v1, 'v2' => v2, 'v3' => v3 }.to_dataset
-    assert_equal(vscale, ds.compute('v1/2'))
+    assert_equal(vnumeric, ds.compute('v1/2'))
     assert_equal(vsum, ds.compute('v1+v2+v3'))
     assert_equal(vmult, ds.compute('v1*v2'))
   end
@@ -447,15 +447,15 @@ class StatsampleDatasetTestCase < Minitest::Test
   def test_crosstab_with_asignation
     v1 = %w(a a a b b b c c c).to_vector
     v2 = %w(a b c a b c a b c).to_vector
-    v3 = %w(0 1 0 0 1 1 0 0 1).to_scale
+    v3 = %w(0 1 0 0 1 1 0 0 1).to_numeric
     ds = Statsample::Dataset.crosstab_by_asignation(v1, v2, v3)
-    assert_equal(:nominal, ds['_id'].type)
-    assert_equal(:scale, ds['a'].type)
-    assert_equal(:scale, ds['b'].type)
+    assert_equal(:object, ds['_id'].type)
+    assert_equal(:numeric, ds['a'].type)
+    assert_equal(:numeric, ds['b'].type)
     ev_id = %w(a b c).to_vector
-    ev_a = %w(0 0 0).to_scale
-    ev_b = %w(1 1 0).to_scale
-    ev_c = %w(0 1 1).to_scale
+    ev_a = %w(0 0 0).to_numeric
+    ev_b = %w(1 1 0).to_numeric
+    ev_c = %w(0 1 1).to_numeric
     ds2 = { '_id' => ev_id, 'a' => ev_a, 'b' => ev_b, 'c' => ev_c }.to_dataset
     assert_equal(ds, ds2)
   end
@@ -472,7 +472,7 @@ class StatsampleDatasetTestCase < Minitest::Test
     ids = %w(1 1 2 2 2).to_vector
     colors = %w(red blue green orange white).to_vector
     values = [10, 20, 15, 30, 20].to_vector
-    col_ids = [1, 2, 1, 2, 3].to_scale
+    col_ids = [1, 2, 1, 2, 3].to_numeric
     ds_expected = { 'id' => ids, '_col_id' => col_ids, 'color' => colors, 'value' => values }.to_dataset(%w(id _col_id color value))
     assert_equal(ds_expected, ds.one_to_many(%w(id), 'car_%v%n'))
   end