statsample-ekatena 2.0.2

data/test/test_awesome_print_bug.rb

@@ -0,0 +1,16 @@
+require(File.expand_path(File.dirname(__FILE__) + '/helpers_tests.rb'))
+class StatsampleAwesomePrintBug < Minitest::Test
+  context('Awesome Print integration') do
+    setup do
+      require 'awesome_print'
+    end
+    should 'should be flawless' do
+      a = Daru::Vector.new([1, 2, 3])
+
+      assert(a != [1, 2, 3])
+      assert_nothing_raised do
+        ap a
+      end
+    end
+  end
+end

data/test/test_bartlettsphericity.rb

@@ -0,0 +1,25 @@
+require(File.expand_path(File.dirname(__FILE__) + '/helpers_tests.rb'))
+
+class StatsampleBartlettSphericityTestCase < Minitest::Test
+  include Statsample::Test
+  context Statsample::Test::BartlettSphericity do
+    setup do
+      @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 = Daru::DataFrame.new({ :v1 => @v1, :v2 => @v2, :v3 => @v3 })
+      cor = Statsample::Bivariate.correlation_matrix(ds)
+      @bs = Statsample::Test::BartlettSphericity.new(cor, 14)
+    end
+    should 'have correct value for chi' do
+      assert_in_delta(9.477, @bs.value, 0.001)
+    end
+    should 'have correct value for df' do
+      assert_equal(3, @bs.df)
+    end
+    should 'have correct value for probability' do
+      assert_in_delta(0.024, @bs.probability, 0.001)
+    end
+  end
+end

data/test/test_bivariate.rb

@@ -0,0 +1,164 @@
+require(File.expand_path(File.dirname(__FILE__) + '/helpers_tests.rb'))
+class StatsampleBivariateTestCase < Minitest::Test
+  should 'method sum of squares should be correct' do
+    v1 = Daru::Vector.new([1, 2, 3, 4, 5, 6])
+    v2 = Daru::Vector.new([6, 2, 4, 10, 12, 8])
+    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 = Daru::Vector.new(20.times.collect { |_a| rand })
+    v2 = Daru::Vector.new(20.times.collect { |_a| rand })
+    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 = Daru::Vector.new(20.times.collect { |_a| rand })
+    v2 = Daru::Vector.new(20.times.collect { |_a| rand })
+
+    assert_in_delta(GSL::Stats.correlation(v1.to_gsl, v2.to_gsl), Statsample::Bivariate.pearson_slow(v1, v2), 1e-10)
+  end
+  should 'return correct pearson correlation' do
+    v1 = Daru::Vector.new([6, 5, 4, 7, 8, 4, 3, 2])
+    v2 = Daru::Vector.new([2, 3, 7, 8, 6, 4, 3, 2])
+    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 = Daru::Vector.new([6, 2,  1000, 1000, 5, 4, 7, 8, 4, 3, 2, nil])
+    v4 = Daru::Vector.new([2, nil, nil, nil,  3, 7, 8, 6, 4, 3, 2, 500])
+    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 = Daru::Vector.new([6, 5, 4, 7, 8, 4, 3, 2])
+    v2 = Daru::Vector.new([2, 3, 7, 8, 6, 4, 3, 2])
+    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)
+    assert_in_delta(Statsample::Bivariate.prop_pearson(r.t, 8, :both), r.probability, 0.001)
+    assert(r.summary.size > 0)
+  end
+  should 'return correct correlation_matrix with nils values' do
+    v1 = Daru::Vector.new([6, 5, 4, 7, 8, 4, 3, 2])
+    v2 = Daru::Vector.new([2, 3, 7, 8, 6, 4, 3, 2])
+    v3 = Daru::Vector.new([6, 2,  1000, 1000, 5, 4, 7, 8])
+    v4 = Daru::Vector.new([2, nil, nil, nil,  3, 7, 8, 6])
+    ds = Daru::DataFrame.new({ :v1 => v1, :v2 => v2, :v3 => v3, :v4 => v4 })
+    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)],
+                      [c.call(v4, v1), c.call(v4, v2), c.call(v4, v3), c.call(v4, v4)]
+    ]
+    obt = Statsample::Bivariate.correlation_matrix(ds)
+    for i in 0...expected.row_size
+      for j in 0...expected.column_size
+        # puts expected[i,j].inspect
+        # puts obt[i,j].inspect
+        assert_in_delta(expected[i, j], obt[i, j], 0.0001, "#{expected[i, j].class}!=#{obt[i, j].class}  ")
+      end
+    end
+    # assert_equal(expected,obt)
+  end
+  should_with_gsl 'return same values for optimized and pairwise covariance matrix' do
+    cases = 100
+    v1 = Daru::Vector.new_with_size(cases) { rand }
+    v2 = Daru::Vector.new_with_size(cases) { rand }
+    v3 = Daru::Vector.new_with_size(cases) { rand }
+    v4 = Daru::Vector.new_with_size(cases) { rand }
+    v5 = Daru::Vector.new_with_size(cases) { rand }
+
+    ds = Daru::DataFrame.new({ :v1 => v1, :v2 => v2, :v3 => v3, :v4 => v4, :v5 => v5 })
+
+    cor_opt = Statsample::Bivariate.covariance_matrix_optimized(ds)
+
+    cor_pw = Statsample::Bivariate.covariance_matrix_pairwise(ds)
+    assert_equal_matrix(cor_opt, cor_pw, 1e-15)
+  end
+  should_with_gsl 'return same values for optimized and pairwise correlation matrix' do
+    cases = 100
+    v1 = Daru::Vector.new_with_size(cases) { rand }
+    v2 = Daru::Vector.new_with_size(cases) { rand }
+    v3 = Daru::Vector.new_with_size(cases) { rand }
+    v4 = Daru::Vector.new_with_size(cases) { rand }
+    v5 = Daru::Vector.new_with_size(cases) { rand }
+
+    ds = Daru::DataFrame.new({ 
+      :v1 => v1, :v2 => v2, :v3 => v3, :v4 => v4, :v5 => v5 })
+
+    cor_opt = Statsample::Bivariate.correlation_matrix_optimized(ds)
+
+    cor_pw = Statsample::Bivariate.correlation_matrix_pairwise(ds)
+    assert_equal_matrix(cor_opt, cor_pw, 1e-15)
+  end
+  should 'return correct correlation_matrix without nils values' do
+    v1 = Daru::Vector.new([6, 5, 4, 7, 8, 4, 3, 2])
+    v2 = Daru::Vector.new([2, 3, 7, 8, 6, 4, 3, 2])
+    v3 = Daru::Vector.new([6, 2,  1000, 1000, 5, 4, 7, 8])
+    v4 = Daru::Vector.new([2, 4, 6, 7,  3, 7, 8, 6])
+    ds = Daru::DataFrame.new({ :v1 => v1, :v2 => v2, :v3 => v3, :v4 => v4 })
+    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)],
+                      [c.call(v4, v1), c.call(v4, v2), c.call(v4, v3), c.call(v4, v4)]
+    ]
+    obt = Statsample::Bivariate.correlation_matrix(ds)
+    for i in 0...expected.row_size
+      for j in 0...expected.column_size
+        # puts expected[i,j].inspect
+        # puts obt[i,j].inspect
+        assert_in_delta(expected[i, j], obt[i, j], 0.0001, "#{expected[i, j].class}!=#{obt[i, j].class}  ")
+      end
+    end
+    # assert_equal(expected,obt)
+  end
+
+  should 'return correct value for prop pearson' do
+    assert_in_delta(0.42, Statsample::Bivariate.prop_pearson(Statsample::Bivariate.t_r(0.084, 94), 94), 0.01)
+    assert_in_delta(0.65, Statsample::Bivariate.prop_pearson(Statsample::Bivariate.t_r(0.046, 95), 95), 0.01)
+    r = 0.9
+    n = 100
+    t = Statsample::Bivariate.t_r(r, n)
+    assert(Statsample::Bivariate.prop_pearson(t, n, :both) < 0.05)
+    assert(Statsample::Bivariate.prop_pearson(t, n, :right) < 0.05)
+    assert(Statsample::Bivariate.prop_pearson(t, n, :left) > 0.05)
+
+    r = -0.9
+    n = 100
+    t = Statsample::Bivariate.t_r(r, n)
+    assert(Statsample::Bivariate.prop_pearson(t, n, :both) < 0.05)
+    assert(Statsample::Bivariate.prop_pearson(t, n, :right) > 0.05)
+    assert(Statsample::Bivariate.prop_pearson(t, n, :left) < 0.05)
+  end
+
+  should "return correct value for Spearman's rho" do
+    v1 =Daru::Vector.new( [86, 97, 99, 100, 101, 103, 106, 110, 112, 113])
+    v2 =Daru::Vector.new( [0, 20, 28, 27, 50, 29, 7, 17, 6, 12])
+    assert_in_delta(-0.175758, Statsample::Bivariate.spearman(v1, v2), 0.0001)
+  end
+  should 'return correct value for point_biserial correlation' do
+    c = Daru::Vector.new([1, 3, 5, 6, 7, 100, 200, 300, 400, 300])
+    d = Daru::Vector.new([1, 1, 1, 1, 1, 0, 0, 0, 0, 0])
+    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 = Daru::Vector.new([1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11])
+    v2 = Daru::Vector.new([1, 3, 4, 5, 7, 8, 2, 9, 10, 6, 11])
+    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 = Daru::Vector.new([12, 14, 14, 17, 19, 19, 19, 19, 19, 20, 21, 21, 21, 21, 21, 22, 23, 24, 24, 24, 26, 26, 27])
+    v2 = Daru::Vector.new([11, 4, 4, 2, 0, 0, 0, 0, 0, 0, 4, 0, 4, 0, 0, 0, 0, 4, 0, 0, 0, 0, 0])
+    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
+    m = Matrix[[10, 5, 2], [10, 15, 20]]
+    assert_in_delta(0.636, Statsample::Bivariate.gamma(m), 0.001)
+    m2 = Matrix[[15, 12, 6, 5], [12, 8, 10, 8], [4, 6, 9, 10]]
+    assert_in_delta(0.349, Statsample::Bivariate.gamma(m2), 0.001)
+  end
+
+  should 'return correct residuals' do
+    # TODO: test Statsample::Bivariate.residuals
+  end
+end

data/test/test_codification.rb

@@ -0,0 +1,78 @@
+require(File.expand_path(File.dirname(__FILE__) + '/helpers_tests.rb'))
+class StatsampleCodificationTestCase < Minitest::Test
+  def initialize(*args)
+    v1 = Daru::Vector.new(%w(run walk,run walking running sleep sleeping,dreaming sleep,dream))
+    @dict = { 'run' => 'r', 'walk' => 'w', 'walking' => 'w', 'running' => 'r', 'sleep' => 's', 'sleeping' => 's', 'dream' => 'd', 'dreaming' => 'd' }
+    @ds = Daru::DataFrame.new({ :v1 => v1 })
+    super
+  end
+
+  def test_create_hash
+    expected_keys_v1 = %w(run walk walking running sleep sleeping dream dreaming).sort
+    hash = Statsample::Codification.create_hash(@ds, [:v1])
+    assert_equal([:v1], hash.keys)
+    assert_equal(expected_keys_v1, hash[:v1].keys.sort)
+    assert_equal(expected_keys_v1, hash[:v1].values.sort)
+  end
+
+  def test_create_excel
+    filename = Dir.tmpdir + '/test_excel' + Time.now.to_s + '.xls'
+    # filename = Tempfile.new("test_codification_"+Time.now().to_s)
+    Statsample::Codification.create_excel(@ds, ['v1'], filename)
+    field = Daru::Vector.new(['v1'] * 8, name: :field)
+    keys = Daru::Vector.new(%w(dream dreaming run running sleep sleeping walk walking))
+    ds = Daru::DataFrame.from_excel(filename)
+    assert_equal(field, ds[:field])
+    assert_equal(keys, ds[:original])
+    assert_equal(keys, ds[:recoded])
+    hash = Statsample::Codification.excel_to_recoded_hash(filename)
+    assert_equal(keys.to_a, hash[:v1].keys.sort)
+    assert_equal(keys.to_a, hash[:v1].values.sort)
+  end
+
+  def test_create_yaml
+    assert_raise ArgumentError do
+      Statsample::Codification.create_yaml(@ds, [])
+    end
+    expected_keys_v1 = %w(run walk walking running sleep sleeping dream dreaming).sort
+    yaml_hash = Statsample::Codification.create_yaml(@ds, [:v1])
+    h = YAML.load(yaml_hash)
+    assert_equal([:v1], h.keys)
+    assert_equal(expected_keys_v1, h[:v1].keys.sort)
+    tf = Tempfile.new('test_codification')
+    yaml_hash = Statsample::Codification.create_yaml(@ds, [:v1], tf, Statsample::SPLIT_TOKEN)
+    tf.close
+    tf.open
+    h = YAML.load(tf)
+    assert_equal([:v1], h.keys)
+    assert_equal(expected_keys_v1, h[:v1].keys.sort)
+    tf.close(true)
+  end
+
+  def test_recodification
+    expected = [['r'], %w(w r), ['w'], ['r'], ['s'], %w(s d), %w(s d)]
+    assert_equal(expected, Statsample::Codification.recode_vector(@ds[:v1], @dict))
+    v2 = Daru::Vector.new(['run', 'walk,dreaming', nil, 'walk,dream,dreaming,walking'])
+    expected = [['r'], %w(w d), nil, %w(w d)]
+    assert_equal(expected, Statsample::Codification.recode_vector(v2, @dict))
+  end
+
+  def test_recode_dataset_simple
+    Statsample::Codification.recode_dataset_simple!(@ds, :v1 => @dict)
+    expected_vector = Daru::Vector.new(['r', 'w,r', 'w', 'r', 's', 's,d', 's,d'])
+    assert_not_equal(expected_vector, @ds[:v1])
+    assert_equal(expected_vector, @ds[:v1_recoded])
+  end
+
+  def test_recode_dataset_split
+    Statsample::Codification.recode_dataset_split!(@ds, :v1 => @dict)
+    e = {}
+    e['r'] = Daru::Vector.new([1, 1, 0, 1, 0, 0, 0])
+    e['w'] = Daru::Vector.new([0, 1, 1, 0, 0, 0, 0])
+    e['s'] = Daru::Vector.new([0, 0, 0, 0, 1, 1, 1])
+    e['d'] = Daru::Vector.new([0, 0, 0, 0, 0, 1, 1])
+    e.each { |k, expected|
+      assert_equal(expected, @ds[('v1_' + k).to_sym], "Error on key #{k}")
+    }
+  end
+end

data/test/test_crosstab.rb

@@ -0,0 +1,67 @@
+require(File.expand_path(File.dirname(__FILE__) + '/helpers_tests.rb'))
+class StatsampleCrosstabTestCase < Minitest::Test
+  def initialize(*args)
+    @v1 =Daru::Vector.new( %w(black blonde black black red black brown black blonde black red black blonde))
+    @v2 =Daru::Vector.new( %w(woman man man woman man man man woman man woman woman man man))
+    @ct = Statsample::Crosstab.new(@v1, @v2)
+    super
+  end
+
+  def test_crosstab_errors
+    e1 = %w(black blonde black black red black brown black blonde black)
+    assert_raise ArgumentError do
+      Statsample::Crosstab.new(e1, @v2)
+    end
+    e2 = Daru::Vector.new(%w(black blonde black black red black brown black blonde black black))
+
+    assert_raise ArgumentError do
+      Statsample::Crosstab.new(e2, @v2)
+    end
+    assert_nothing_raised do
+      Statsample::Crosstab.new(@v1, @v2)
+    end
+  end
+
+  def test_crosstab_basic
+    assert_equal(Daru::Vector.new(%w(black blonde brown red)), @ct.rows_names)
+    assert_equal(Daru::Vector.new(%w(man woman)), @ct.cols_names)
+    assert_equal({ 'black' => 7, 'blonde' => 3, 'red' => 2, 'brown' => 1 }, @ct.rows_total)
+    assert_equal({ 'man' => 8, 'woman' => 5 }, @ct.cols_total)
+  end
+
+  def test_crosstab_frequencies
+    fq = @ct.frequencies
+    assert_equal(8, fq.size)
+    sum = fq.inject(0) { |s, x| s + x[1] }
+    assert_equal(13, sum)
+    fr = @ct.frequencies_by_row
+    assert_equal(4, fr.size)
+    assert_equal(%w(black blonde brown red), fr.keys.sort)
+    fc = @ct.frequencies_by_col
+    assert_equal(2, fc.size)
+    assert_equal(%w(man woman), fc.keys.sort)
+    assert_equal(Matrix.rows([[3, 4], [3, 0], [1, 0], [1, 1]]), @ct.to_matrix)
+  end
+
+  def test_summary
+    @ct.percentage_row = true
+    @ct.percentage_column = true
+    @ct.percentage_total = true
+    assert(@ct.summary.size > 0)
+  end
+
+  def test_expected
+    v1 = Daru::Vector.new(%w(1 1 1 1 1 0 0 0 0 0))
+    v2 = Daru::Vector.new(%w(0 0 0 0 0 1 1 1 1 1))
+    ct = Statsample::Crosstab.new(v1, v2)
+    assert_equal(Matrix[[2.5, 2.5], [2.5, 2.5]], ct.matrix_expected)
+  end
+
+  def test_crosstab_with_scale
+    v1 = Daru::Vector.new(%w(1 1 1 1 1 0 0 0 0 0))
+    v2 = Daru::Vector.new(%w(0 0 0 0 0 1 1 1 1 1))
+    ct = Statsample::Crosstab.new(v1, v2)
+    assert_equal(Matrix[[0, 5], [5, 0]], ct.to_matrix)
+    assert_nothing_raised { ct.summary }
+  end
+end

data/test/test_dominance_analysis.rb

@@ -0,0 +1,39 @@
+require(File.expand_path(File.dirname(__FILE__) + '/helpers_tests.rb'))
+class StatsampleDominanceAnalysisTestCase < Minitest::Test
+  def test_dominance_univariate
+    # Example from Budescu (1993)
+    m = Matrix[[1, 0.683, 0.154, 0.460, 0.618], [0.683, 1, -0.050, 0.297, 0.461], [0.154, -0.050, 1, 0.006, 0.262], [0.460, 0.297, 0.006, 1, 0.507], [0.618, 0.461, 0.262, 0.507, 1]]
+    m.extend Statsample::CovariateMatrix
+    m.fields = %w(x1 x2 x3 x4 y)
+    da = Statsample::DominanceAnalysis.new(m, 'y')
+
+    contr_x1 = { 'x2' => 0.003, 'x3' => 0.028, 'x4' => 0.063 }
+    contr_x1.each  do |k, v|
+      assert_in_delta(v, da.models_data[['x1']].contributions[k], 0.001)
+    end
+    assert_in_delta(0.052, da.models_data[%w(x2 x3 x4)].contributions['x1'], 0.001)
+    expected_dominances = [1, 1, 0.5, 0.5, 0, 0]
+    expected_g_dominances = [1, 1, 1, 1, 0, 0]
+
+    da.pairs.each_with_index do |a, i|
+      assert_equal(expected_dominances[i], da.total_dominance_pairwise(a[0], a[1]))
+      assert_equal(expected_dominances[i], da.conditional_dominance_pairwise(a[0], a[1]))
+      assert_equal(expected_g_dominances[i], da.general_dominance_pairwise(a[0], a[1]))
+    end
+    assert(da.summary.size > 0)
+  end
+
+  def test_dominance_multivariate
+    m = Matrix[[1.0, -0.19, -0.358, -0.343, 0.359, 0.257], [-0.19, 1.0, 0.26, 0.29, -0.11, -0.11], [-0.358, 0.26, 1.0, 0.54, -0.49, -0.23], [-0.343, 0.29, 0.54, 1.0, -0.22, -0.41], [0.359, -0.11, -0.49, -0.22, 1.0, 0.62], [0.257, -0.11, -0.23, -0.41, 0.62, 1]]
+    m.extend Statsample::CovariateMatrix
+    m.fields = %w(y1 y2 x1 x2 x3 x4)
+    m2 = m.submatrix(%w(y1 x1 x2 x3 x4))
+
+    da = Statsample::DominanceAnalysis.new(m, %w(y1 y2), cases: 683, method_association: :p2yx)
+
+    contr_x1 = { 'x2' => 0.027, 'x3' => 0.024, 'x4' => 0.017 }
+    contr_x1.each  do |k, v|
+      assert_in_delta(v, da.models_data[['x1']].contributions[k], 0.003)
+    end
+  end
+end

data/test/test_factor.rb

@@ -0,0 +1,228 @@
+require(File.expand_path(File.dirname(__FILE__) + '/helpers_tests.rb'))
+# require 'rserve'
+# require 'statsample/rserve_extension'
+
+class StatsampleFactorTestCase < Minitest::Test
+  include Statsample::Fixtures
+  # Based on Hardle and Simar
+  def setup
+    @fixtures_dir = File.expand_path(File.dirname(__FILE__) + '/fixtures')
+  end
+
+  # Based on Hurdle example
+  def test_covariance_matrix
+    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 = Statsample::Bivariate.covariance_matrix ds
+    pca = Statsample::Factor::PCA.new(cm, m: 6)
+    # puts pca.summary
+    # puts pca.feature_matrix
+    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}".to_sym
+      k.times {|j| # variable
+        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])
+      }
+    }
+  end
+
+  def test_principalcomponents_ruby_gsl
+    if Statsample.has_gsl?
+      ran = Distribution::Normal.rng
+
+      #    @r=::Rserve::Connection.new
+
+      samples = 20
+      [3, 5, 7].each {|k|
+        v = {}
+        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 = 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"
+        #      puts @r.eval('v').to_ruby.to_s
+        pca_ruby = Statsample::Factor::PCA.new(cm, m: k, use_gsl: false)
+        pca_gsl = Statsample::Factor::PCA.new(cm, m: k, use_gsl: true)
+        pc_ruby = pca_ruby.principal_components(ds)
+        pc_gsl  = pca_gsl.principal_components(ds)
+        # Test component matrix correlation!
+        cm_ruby = pca_ruby.component_matrix
+        # puts cm_ruby.summary
+        k.times {|i|
+          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}".to_sym
+              r = Statsample::Bivariate.correlation(ds[ds_id], pc_ruby[pc_id])
+              puts "#{pc_id}-#{ds_id}:#{r}"
+            }
+          end
+        }
+      }
+    end
+    # @r.close
+  end
+
+  def test_principalcomponents
+    if Statsample.has_gsl?
+      principalcomponents(true)
+    else
+      skip "Require GSL"
+    end
+    principalcomponents(false)
+  end
+
+  def principalcomponents(gsl)
+    ran = Distribution::Normal.rng
+    samples = 50
+    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 = 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)
+    assert_in_delta(1 - r, pca.eigenvalues[1], 1e-10)
+    hs = 1.0 / Math.sqrt(2)
+    assert_equal_vector(Vector[1, 1] * hs, pca.eigenvectors[0])
+    m_1 = gsl ? Vector[-1, 1] : Vector[1, -1]
+
+    assert_equal_vector(hs * m_1, pca.eigenvectors[1])
+
+    pcs = pca.principal_components(ds)
+    exp_pc_1 = ds.collect_row_with_index {|row, _i|
+      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])
+  end
+
+  def test_antiimage
+    cor = Matrix[[1, 0.964, 0.312], [0.964, 1, 0.411], [0.312, 0.411, 1]]
+    expected = Matrix[[0.062, -0.057, 0.074], [-0.057, 0.057, -0.089], [0.074, -0.089, 0.729]]
+    ai = Statsample::Factor.anti_image_covariance_matrix(cor)
+    assert(Matrix.equal_in_delta?(expected, ai, 0.01), "#{expected} not equal to #{ai}")
+  end
+
+  def test_kmo
+    @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 = 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)
+    assert_in_delta(0.81, Statsample::Factor.kmo(harman_817), 0.01)
+  end
+
+  def test_kmo_univariate
+    m = harman_817
+    expected = [0.73, 0.76, 0.84, 0.87, 0.53, 0.93, 0.78, 0.86]
+    m.row_size.times.map {|i|
+      assert_in_delta(expected[i], Statsample::Factor.kmo_univariate(m, i), 0.01)
+    }
+  end
+  # Tested with SPSS and R
+  def test_pca
+    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?
+      pca = Statsample::Factor::PCA.new(cov_matrix, use_gsl: true)
+      pca_set(pca, 'gsl')
+    else
+      skip('Eigenvalues could be calculated with GSL (requires gsl)')
+    end
+    pca = Statsample::Factor::PCA.new(cov_matrix, use_gsl: false)
+    pca_set(pca, 'ruby')
+  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)
+    }
+    expected_communality = [0.590, 0.694]
+    expected_communality.each_with_index{|ev, i|
+      assert_in_delta(ev, pca.communalities[i], 0.001)
+    }
+    expected_cm = [0.768, 0.833]
+    obs = pca.component_matrix_correlation(1).column(0).to_a
+    expected_cm.each_with_index{|ev, i|
+      assert_in_delta(ev, obs[i], 0.001)
+    }
+
+    assert(pca.summary)
+  end
+
+  # Tested with R
+  def test_principalaxis
+    matrix = ::Matrix[
+    [1.0, 0.709501601093587, 0.877596585880047, 0.272219316266807],  [0.709501601093587, 1.0, 0.291633797330304, 0.871141831433844], [0.877596585880047, 0.291633797330304, 1.0, -0.213373722977167], [0.272219316266807, 0.871141831433844, -0.213373722977167, 1.0]]
+
+    fa = Statsample::Factor::PrincipalAxis.new(matrix, m: 1, max_iterations: 50)
+
+    cm = ::Matrix[[0.923], [0.912], [0.507], [0.483]]
+
+    assert_equal_matrix(cm, fa.component_matrix, 0.001)
+
+    h2 = [0.852, 0.832, 0.257, 0.233]
+    h2.each_with_index{|ev, i|
+      assert_in_delta(ev, fa.communalities[i], 0.001)
+    }
+    eigen1 = 2.175
+    assert_in_delta(eigen1, fa.eigenvalues[0], 0.001)
+    assert(fa.summary.size > 0)
+    fa = Statsample::Factor::PrincipalAxis.new(matrix, smc: false)
+
+    assert_raise RuntimeError do
+      fa.iterate
+    end
+  end
+
+  def test_rotation_varimax
+    a = Matrix[[0.4320,  0.8129,  0.3872],
+               [0.7950, -0.5416,  0.2565],
+               [0.5944,  0.7234, -0.3441],
+               [0.8945, -0.3921, -0.1863]]
+
+    expected = Matrix[[-0.0204423,     0.938674,    -0.340334],
+                      [0.983662, 0.0730206, 0.134997],
+                      [0.0826106, 0.435975, -0.893379],
+                      [0.939901, -0.0965213, -0.309596]]
+    varimax = Statsample::Factor::Varimax.new(a)
+    assert(!varimax.rotated.nil?, "Rotated shouldn't be empty")
+    assert(!varimax.component_transformation_matrix.nil?, "Component matrix shouldn't be empty")
+    assert(!varimax.h2.nil?, "H2 shouldn't be empty")
+
+    assert_equal_matrix(expected, varimax.rotated, 1e-6)
+    assert(varimax.summary.size > 0)
+  end
+end